From a8fd343fc1d4ecb3d1579fa512bb9d66161a5648 Mon Sep 17 00:00:00 2001 From: ahmad Date: Fri, 9 Oct 2026 22:31:58 +0300 Subject: [PATCH] feat(vkbridge): Vulkan bridge core - codegen, wire runtime, server, client ICD, WSI Generated from vk.xml 1.3.247; server shares host-visible memory via a self-tested strategy (hostptr/dmabuf/ahb). vulkaninfo runs through it on host. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01KZqR8XUE8czvGzEpgSCVQR --- app/src/main/cpp/vkbridge/server_conn.c | 332 + app/src/main/cpp/vkbridge/server_emu.c | 111 + app/src/main/cpp/vkbridge/server_emu.h | 24 + app/src/main/cpp/vkbridge/server_emu_layer.c | 23 + app/src/main/cpp/vkbridge/server_instance.c | 323 + app/src/main/cpp/vkbridge/server_main.c | 180 + app/src/main/cpp/vkbridge/server_memory.c | 667 + app/src/main/cpp/vkbridge/server_misc.c | 50 + app/src/main/cpp/vkbridge/vkb_server.h | 116 + tools/vkbridge/client/cmdbuf.c | 231 + tools/vkbridge/client/compat/X11/Xlib.h | 10 + tools/vkbridge/client/compat/xcb/xcb.h | 37 + tools/vkbridge/client/conn.c | 449 + tools/vkbridge/client/descriptor.c | 270 + tools/vkbridge/client/emu.c | 35 + tools/vkbridge/client/emu.h | 24 + tools/vkbridge/client/icd.c | 586 + tools/vkbridge/client/memory.c | 433 + tools/vkbridge/client/physdev.c | 367 + tools/vkbridge/client/vkb_client.h | 177 + tools/vkbridge/client/wsi.c | 756 + tools/vkbridge/client/wsi.h | 99 + tools/vkbridge/client/wsi_wayland.c | 558 + tools/vkbridge/client/wsi_x11.c | 162 + tools/vkbridge/codegen/gen_vkbridge.py | 1343 + tools/vkbridge/common/gen/vkb_client_gen.h | 397 + tools/vkbridge/common/gen/vkb_gen.h | 2094 ++ tools/vkbridge/common/gen/vkb_gen_client.c | 6735 +++++ tools/vkbridge/common/gen/vkb_gen_server.c | 7217 +++++ tools/vkbridge/common/gen/vkb_gen_structs.c | 12361 ++++++++ tools/vkbridge/common/gen/vkb_server_gen.h | 285 + tools/vkbridge/common/vkb_log.h | 24 + tools/vkbridge/common/vkb_proto.h | 58 + tools/vkbridge/common/vkb_server_iface.h | 29 + tools/vkbridge/common/vkb_wire.c | 691 + tools/vkbridge/common/vkb_wire.h | 118 + tools/vkbridge/host/.gitignore | 1 + tools/vkbridge/host/Makefile | 39 + .../Vulkan-Headers-1.3.247/LICENSE.txt | 202 + .../vk_video/vulkan_video_codec_h264std.h | 310 + .../vulkan_video_codec_h264std_decode.h | 75 + .../vulkan_video_codec_h264std_encode.h | 141 + .../vk_video/vulkan_video_codec_h265std.h | 443 + .../vulkan_video_codec_h265std_decode.h | 65 + .../vulkan_video_codec_h265std_encode.h | 150 + .../vk_video/vulkan_video_codecs_common.h | 31 + .../include/vulkan/vk_icd.h | 258 + .../include/vulkan/vk_layer.h | 203 + .../include/vulkan/vk_platform.h | 84 + .../include/vulkan/vulkan.h | 99 + .../include/vulkan/vulkan_android.h | 125 + .../include/vulkan/vulkan_beta.h | 537 + .../include/vulkan/vulkan_core.h | 17178 +++++++++++ .../include/vulkan/vulkan_directfb.h | 54 + .../include/vulkan/vulkan_fuchsia.h | 258 + .../include/vulkan/vulkan_ggp.h | 58 + .../include/vulkan/vulkan_ios.h | 47 + .../include/vulkan/vulkan_macos.h | 47 + .../include/vulkan/vulkan_metal.h | 193 + .../include/vulkan/vulkan_screen.h | 54 + .../include/vulkan/vulkan_vi.h | 47 + .../include/vulkan/vulkan_wayland.h | 54 + .../include/vulkan/vulkan_win32.h | 333 + .../include/vulkan/vulkan_xcb.h | 55 + .../include/vulkan/vulkan_xlib.h | 55 + .../include/vulkan/vulkan_xlib_xrandr.h | 45 + .../Vulkan-Headers-1.3.247/registry/vk.xml | 24198 ++++++++++++++++ 67 files changed, 82811 insertions(+) create mode 100644 app/src/main/cpp/vkbridge/server_conn.c create mode 100644 app/src/main/cpp/vkbridge/server_emu.c create mode 100644 app/src/main/cpp/vkbridge/server_emu.h create mode 100644 app/src/main/cpp/vkbridge/server_emu_layer.c create mode 100644 app/src/main/cpp/vkbridge/server_instance.c create mode 100644 app/src/main/cpp/vkbridge/server_main.c create mode 100644 app/src/main/cpp/vkbridge/server_memory.c create mode 100644 app/src/main/cpp/vkbridge/server_misc.c create mode 100644 app/src/main/cpp/vkbridge/vkb_server.h create mode 100644 tools/vkbridge/client/cmdbuf.c create mode 100644 tools/vkbridge/client/compat/X11/Xlib.h create mode 100644 tools/vkbridge/client/compat/xcb/xcb.h create mode 100644 tools/vkbridge/client/conn.c create mode 100644 tools/vkbridge/client/descriptor.c create mode 100644 tools/vkbridge/client/emu.c create mode 100644 tools/vkbridge/client/emu.h create mode 100644 tools/vkbridge/client/icd.c create mode 100644 tools/vkbridge/client/memory.c create mode 100644 tools/vkbridge/client/physdev.c create mode 100644 tools/vkbridge/client/vkb_client.h create mode 100644 tools/vkbridge/client/wsi.c create mode 100644 tools/vkbridge/client/wsi.h create mode 100644 tools/vkbridge/client/wsi_wayland.c create mode 100644 tools/vkbridge/client/wsi_x11.c create mode 100644 tools/vkbridge/codegen/gen_vkbridge.py create mode 100644 tools/vkbridge/common/gen/vkb_client_gen.h create mode 100644 tools/vkbridge/common/gen/vkb_gen.h create mode 100644 tools/vkbridge/common/gen/vkb_gen_client.c create mode 100644 tools/vkbridge/common/gen/vkb_gen_server.c create mode 100644 tools/vkbridge/common/gen/vkb_gen_structs.c create mode 100644 tools/vkbridge/common/gen/vkb_server_gen.h create mode 100644 tools/vkbridge/common/vkb_log.h create mode 100644 tools/vkbridge/common/vkb_proto.h create mode 100644 tools/vkbridge/common/vkb_server_iface.h create mode 100644 tools/vkbridge/common/vkb_wire.c create mode 100644 tools/vkbridge/common/vkb_wire.h create mode 100644 tools/vkbridge/host/.gitignore create mode 100644 tools/vkbridge/host/Makefile create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/LICENSE.txt create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std_decode.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std_encode.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std_decode.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std_encode.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codecs_common.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_icd.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_layer.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_platform.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_android.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_beta.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_core.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_directfb.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_fuchsia.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_ggp.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_ios.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_macos.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_metal.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_screen.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_vi.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_wayland.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_win32.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xcb.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xlib.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xlib_xrandr.h create mode 100644 tools/vkbridge/third_party/Vulkan-Headers-1.3.247/registry/vk.xml diff --git a/app/src/main/cpp/vkbridge/server_conn.c b/app/src/main/cpp/vkbridge/server_conn.c new file mode 100644 index 000000000..4c7e64740 --- /dev/null +++ b/app/src/main/cpp/vkbridge/server_conn.c @@ -0,0 +1,332 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Connections: one thread per client thread, requests executed in order, replies sent back. + * A command buffer's recorded commands arrive in one message at vkEndCommandBuffer and are + * replayed here. + */ +#define _GNU_SOURCE +#include "vkb_server.h" + +#include +#include +#include +#include +#include + +static pthread_mutex_t tables_lock = PTHREAD_MUTEX_INITIALIZER; +static vkb_srv_table *tables[VKB_MAX_TABLES]; +static uint32_t next_table_id = 1; + +static pthread_mutex_t procs_lock = PTHREAD_MUTEX_INITIALIZER; +static vkb_srv_proc *procs; + +static __thread vkb_srv_table *tls_table; + +vkb_srv_table *vkb_srv_current_table(void) { return tls_table; } +void vkb_srv_set_current_table(vkb_srv_table *t) { tls_table = t; } + +/* Server side of the generated encoders' helpers: handles are already the server's values. */ +uint64_t vkb_remote(const void *h) { return (uint64_t)(uintptr_t)h; } +int vkb_cb_begin_is_secondary(const VkCommandBufferBeginInfo *s) { (void)s; return 1; } + +uint32_t vkb_table_register(vkb_srv_table *t) +{ + pthread_mutex_lock(&tables_lock); + uint32_t id = 0; + for (uint32_t tries = 0; tries < VKB_MAX_TABLES; tries++) { + uint32_t cand = next_table_id++; + if (next_table_id >= VKB_MAX_TABLES) next_table_id = 1; + if (!tables[cand]) { + id = cand; + break; + } + } + if (id) { + t->id = id; + tables[id] = t; + } + pthread_mutex_unlock(&tables_lock); + return id; +} + +void vkb_table_unregister(vkb_srv_table *t) +{ + pthread_mutex_lock(&tables_lock); + if (t->id && t->id < VKB_MAX_TABLES && tables[t->id] == t) tables[t->id] = NULL; + pthread_mutex_unlock(&tables_lock); +} + +vkb_srv_table *vkb_table_get(uint32_t id) +{ + if (!id || id >= VKB_MAX_TABLES) return NULL; + pthread_mutex_lock(&tables_lock); + vkb_srv_table *t = tables[id]; + pthread_mutex_unlock(&tables_lock); + return t; +} + +void vkb_srv_reply_status(vkb_srv_call *c, uint32_t status) +{ + c->status = status; +} + +void vkb_srv_bad_message(vkb_srv_call *c) +{ + VKB_ERR("malformed request"); + c->status = VKB_ST_BAD_MESSAGE; +} + +void vkb_srv_missing(vkb_srv_call *c, const char *name) +{ + VKB_ERR("the driver has no %s", name); + c->status = VKB_ST_MISSING; +} + +void vkb_srv_close_after_send(vkb_srv_call *c, int fd) +{ + if (c->nclose < VKB_MAX_FDS) c->close_after[c->nclose++] = fd; +} + +/* ------------------------------------------------------------------ process cleanup */ + +void vkb_proc_cleanup(vkb_srv_proc *p) +{ + /* Devices first, then their instances. */ + for (int pass = 0; pass < 2; pass++) { + for (uint32_t i = 1; i < VKB_MAX_TABLES; i++) { + pthread_mutex_lock(&tables_lock); + vkb_srv_table *t = tables[i]; + int mine = t && t->proc == p && t->is_device == (pass == 0); + if (mine) tables[i] = NULL; + pthread_mutex_unlock(&tables_lock); + if (!mine) continue; + if (t->is_device) { + VKB_INFO("process %d exited without destroying device %u; cleaning up", p->pid, t->id); + if (t->real.vkDeviceWaitIdle) t->real.vkDeviceWaitIdle(t->device); + vkb_emu_device_destroy(t); + vkb_mem_free_all(t); + t->real.vkDestroyDevice(t->device, NULL); + } else { + VKB_INFO("process %d exited without destroying instance %u; cleaning up", p->pid, t->id); + t->real.vkDestroyInstance(t->instance, NULL); + } + pthread_mutex_destroy(&t->lock); + free(t); + } + } +} + +static vkb_srv_proc *proc_join(uint64_t token, int pid) +{ + pthread_mutex_lock(&procs_lock); + vkb_srv_proc *p = procs; + while (p && p->token != token) p = p->next; + if (!p) { + p = calloc(1, sizeof(*p)); + p->token = token; + p->pid = pid; + p->next = procs; + procs = p; + VKB_INFO("client process %d connected", pid); + } + p->conns++; + pthread_mutex_unlock(&procs_lock); + return p; +} + +static void proc_leave(vkb_srv_proc *p) +{ + pthread_mutex_lock(&procs_lock); + int last = --p->conns == 0; + if (last) { + vkb_srv_proc **pp = &procs; + while (*pp && *pp != p) pp = &(*pp)->next; + if (*pp) *pp = p->next; + } + pthread_mutex_unlock(&procs_lock); + if (last) { + vkb_proc_cleanup(p); + VKB_INFO("client process %d gone", p->pid); + free(p); + } +} + +/* ------------------------------------------------------------------ command buffer replay */ + +static int is_stream_cmd(uint32_t id) +{ + const char *n = vkb_cmd_names[id]; + return !strncmp(n, "vkCmd", 5) || id == VKB_CMD_vkBeginCommandBuffer || id == VKB_CMD_vkbPushDescRaw; +} + +void vkb_sv_vkEndCommandBuffer(vkb_srv_call *c) +{ + VkCommandBuffer cb = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(&c->d); + size_t len = 0; + const uint8_t *s = vkb_dec_blob(&c->d, &len); + if (c->d.err) { + vkb_srv_bad_message(c); + return; + } + VkResult begin_r = VK_SUCCESS; + size_t pos = 0; + vkb_enc scratch; + vkb_enc_init(&scratch); + uint32_t ncmds = 0; + while (s && pos + 8 <= len) { + uint32_t id, n; + memcpy(&id, s + pos, 4); + memcpy(&n, s + pos + 4, 4); + pos += 8; + if (id >= VKB_CMD_COUNT || !is_stream_cmd(id) || n > len - pos) { + VKB_ERR("command stream: bad entry (id %u, %u bytes) after %u commands", id, n, ncmds); + c->status = VKB_ST_BAD_MESSAGE; + vkb_enc_free(&scratch); + return; + } + vkb_srv_call sub; + memset(&sub, 0, sizeof(sub)); + vkb_dec_init(&sub.d, s + pos, n, c->d.arena, NULL, 0); + sub.r = scratch; + vkb_enc_reset(&sub.r); + sub.dt = c->dt; + sub.table = c->table; + sub.conn = c->conn; + sub.in_stream = 1; + vkb_srv_handlers[id](&sub); + scratch = sub.r; + if (sub.status != VKB_ST_OK) { + VKB_ERR("command stream: %s failed (status %u)", vkb_cmd_names[id], sub.status); + } + if (id == VKB_CMD_vkBeginCommandBuffer && scratch.len >= 4) memcpy(&begin_r, scratch.buf, 4); + pos += (n + 7) & ~(size_t)7; + ncmds++; + } + vkb_enc_free(&scratch); + VkResult r = c->dt->vkEndCommandBuffer(cb); + if (begin_r != VK_SUCCESS) r = begin_r; + if (vkb_verbose) VKB_DBG("command buffer %p: %u commands, %zu bytes -> %d", (void *)cb, ncmds, len, r); + vkb_enc_u32(&c->r, (uint32_t)r); +} + +/* ------------------------------------------------------------------ hello */ + +void vkb_sv_vkbHello(vkb_srv_call *c) +{ + uint64_t hash = vkb_dec_u64(&c->d); + uint64_t token = vkb_dec_u64(&c->d); + uint32_t pid = vkb_dec_u32(&c->d); + const char *comm = vkb_dec_str(&c->d); + if (c->d.err) { + vkb_srv_bad_message(c); + return; + } + vkb_enc_u64(&c->r, VKB_PROTOCOL_HASH); + if (hash != VKB_PROTOCOL_HASH) { + VKB_ERR("client %d (%s) speaks protocol %016llx, this server %016llx: refusing", pid, + comm ? comm : "?", (unsigned long long)hash, (unsigned long long)VKB_PROTOCOL_HASH); + vkb_enc_u32(&c->r, 0); + return; + } + if (!c->conn->proc) { + c->conn->proc = proc_join(token, (int)pid); + if (c->conn->proc->conns == 1) VKB_INFO("process %u is %s", pid, comm ? comm : "?"); + } + vkb_enc_u32(&c->r, 1); +} + +/* ------------------------------------------------------------------ connection loop */ + +static void *conn_main(void *arg) +{ + vkb_srv_conn *conn = arg; + vkb_srv_call c; + vkb_enc_init(&c.r); + int fds[VKB_MAX_FDS]; + for (;;) { + vkb_msg_hdr h; + int nfds = 0; + if (vkb_recv_msg(conn->sock, &h, &conn->inbuf, &conn->incap, fds, &nfds) < 0) break; + vkb_enc_reset(&c.r); + vkb_dec_init(&c.d, conn->inbuf, h.size, &conn->arena, fds, nfds); + c.conn = conn; + c.status = VKB_ST_OK; + c.nclose = 0; + c.in_stream = 0; + c.table = NULL; + c.dt = &vkb_global_dt; + if (h.cmd >= VKB_CMD_COUNT) { + VKB_ERR("unknown command id %u", h.cmd); + c.status = VKB_ST_BAD_MESSAGE; + } else if (!conn->proc && h.cmd != VKB_CMD_vkbHello) { + VKB_ERR("%s before hello", vkb_cmd_names[h.cmd]); + c.status = VKB_ST_BAD_MESSAGE; + } else { + if (h.table) { + c.table = vkb_table_get(h.table); + if (!c.table || c.table->proc != conn->proc) { + VKB_ERR("%s: unknown dispatch table %u", vkb_cmd_names[h.cmd], h.table); + c.status = VKB_ST_BAD_TABLE; + } else { + c.dt = &c.table->dt; + } + } + if (c.status == VKB_ST_OK) { + vkb_srv_set_current_table(c.table); + if (vkb_verbose) VKB_DBG("-> %s", vkb_cmd_names[h.cmd]); + vkb_srv_handlers[h.cmd](&c); + vkb_srv_set_current_table(NULL); + } + } + vkb_dec_close_untaken(&c.d); + if (!(h.flags & VKB_F_NOREPLY)) { + vkb_msg_hdr rh = {VKB_MAGIC, c.status == VKB_ST_OK ? (uint32_t)c.r.len : 0, c.status, 0, + c.status == VKB_ST_OK ? (uint32_t)c.r.nfds : 0, 0}; + if (c.r.oom) { + rh.cmd = VKB_ST_BAD_MESSAGE; + rh.size = 0; + rh.nfds = 0; + } + if (vkb_send_msg(conn->sock, &rh, c.r.buf, c.r.fds, (int)rh.nfds) < 0) { + for (int i = 0; i < c.nclose; i++) close(c.close_after[i]); + break; + } + } else if (c.status != VKB_ST_OK) { + VKB_ERR("asynchronous %s failed (status %u)", vkb_cmd_names[h.cmd], c.status); + } + for (int i = 0; i < c.nclose; i++) close(c.close_after[i]); + vkb_arena_reset(&conn->arena); + } + close(conn->sock); + vkb_enc_free(&c.r); + free(conn->inbuf); + vkb_arena_free(&conn->arena); + if (conn->proc) proc_leave(conn->proc); + free(conn); + return NULL; +} + +void vkb_srv_serve(int lfd) +{ + for (;;) { + int s = accept4(lfd, NULL, NULL, SOCK_CLOEXEC); + if (s < 0) { + if (errno == EINTR || errno == ECONNABORTED) continue; + VKB_ERR("accept: %s", strerror(errno)); + continue; + } + vkb_srv_conn *conn = calloc(1, sizeof(*conn)); + conn->sock = s; + pthread_attr_t attr; + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + /* Driver calls (pipeline compiles) can use a lot of stack. */ + pthread_attr_setstacksize(&attr, 4u << 20); + if (pthread_create(&conn->thread, &attr, conn_main, conn) != 0) { + VKB_ERR("cannot start a connection thread"); + close(s); + free(conn); + } + pthread_attr_destroy(&attr); + } +} diff --git a/app/src/main/cpp/vkbridge/server_emu.c b/app/src/main/cpp/vkbridge/server_emu.c new file mode 100644 index 000000000..02474ec20 --- /dev/null +++ b/app/src/main/cpp/vkbridge/server_emu.c @@ -0,0 +1,111 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Feature emulation: entry point. What the GPU lacks and the bridge can make up for is decided + * here per physical device; the client reports those features as present, the server strips + * them from vkCreateDevice and installs wrappers in the device's dispatch table. + */ +#define _GNU_SOURCE +#include "vkb_server.h" +#include "server_emu.h" + +#include +#include + +static int env_off(const char *name) +{ + const char *v = getenv(name); + return v && !strcmp(v, "0"); +} + +uint32_t vkb_emu_detect(const vkb_dispatch *idt, VkPhysicalDevice pd) +{ + VkPhysicalDeviceFeatures f; + idt->vkGetPhysicalDeviceFeatures(pd, &f); + uint32_t n = 0; + idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, NULL); + VkExtensionProperties *e = calloc(n ? n : 1, sizeof(*e)); + idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, e); + int divisor = 0, depth_clip = 0; + for (uint32_t i = 0; i < n; i++) { + if (!strcmp(e[i].extensionName, "VK_EXT_vertex_attribute_divisor") || + !strcmp(e[i].extensionName, "VK_KHR_vertex_attribute_divisor")) + divisor = 1; + if (!strcmp(e[i].extensionName, "VK_EXT_depth_clip_enable")) depth_clip = 1; + } + free(e); + /* VKBRIDGE_FAKE_MISSING=bc,divisor,clip,cull,depthclip pretends the GPU lacks them (host tests). */ + const char *fake = getenv("VKBRIDGE_FAKE_MISSING"); + if (fake) { + if (strstr(fake, "bc")) f.textureCompressionBC = VK_FALSE; + if (strstr(fake, "divisor")) divisor = 0; + if (strstr(fake, "clip")) f.shaderClipDistance = VK_FALSE; + if (strstr(fake, "cull")) f.shaderCullDistance = VK_FALSE; + if (strstr(fake, "depthclip")) depth_clip = 0; + } + uint32_t emu = 0; + if (!f.textureCompressionBC && vkb_emu_bcn_supported(idt, pd) && !env_off("VKBRIDGE_EMU_BCN")) emu |= VKB_EMU_BCN; + if (!divisor && !env_off("VKBRIDGE_EMU_DIVISOR")) emu |= VKB_EMU_DIVISOR; + if (!f.shaderClipDistance && !env_off("VKBRIDGE_EMU_CLIP")) emu |= VKB_EMU_CLIP_DISTANCE; + if (!f.shaderCullDistance && !env_off("VKBRIDGE_EMU_CULL")) emu |= VKB_EMU_CULL_DISTANCE; + if (!depth_clip && f.depthClamp && !env_off("VKBRIDGE_EMU_DEPTHCLIP")) emu |= VKB_EMU_DEPTH_CLIP; + /* PointSize in geometry/tessellation stages: stripped when the feature is missing. */ + if (!f.shaderTessellationAndGeometryPointSize && (f.geometryShader || f.tessellationShader)) emu |= VKB_EMU_POINT_SIZE; + return emu & VKB_EMU_IMPLEMENTED; +} + +/* Remove a structure from a pNext chain (the chain lives in the request's arena). */ +static void chain_remove(VkDeviceCreateInfo *ci, VkStructureType t) +{ + VkBaseOutStructure *prev = (VkBaseOutStructure *)ci; + while (prev->pNext) { + if (prev->pNext->sType == t) prev->pNext = prev->pNext->pNext; + else prev = prev->pNext; + } +} + +static VkPhysicalDeviceFeatures *find_features(VkDeviceCreateInfo *ci) +{ + if (ci->pEnabledFeatures) return (VkPhysicalDeviceFeatures *)ci->pEnabledFeatures; + for (VkBaseOutStructure *b = (VkBaseOutStructure *)ci->pNext; b; b = b->pNext) + if (b->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2) return &((VkPhysicalDeviceFeatures2 *)b)->features; + return NULL; +} + +void vkb_emu_device_create_info(vkb_srv_table *inst, VkPhysicalDevice pd, uint32_t emu, VkDeviceCreateInfo *ci, vkb_arena *a) +{ + VkPhysicalDeviceFeatures real; + inst->real.vkGetPhysicalDeviceFeatures(pd, &real); + VkPhysicalDeviceFeatures *f = find_features(ci); + if (f) { + /* pEnabledFeatures came from the request: it is ours to change. Anything the client asked + * for that the GPU does not have is either emulated or would fail the call. */ + VkBool32 *want = (VkBool32 *)f; + const VkBool32 *have = (const VkBool32 *)ℜ + for (size_t i = 0; i < sizeof(*f) / sizeof(VkBool32); i++) { + if (want[i] && !have[i]) want[i] = VK_FALSE; + } + } + if (emu & VKB_EMU_DIVISOR) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT); + if (emu & VKB_EMU_DEPTH_CLIP) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT); + (void)a; +} + +void vkb_emu_device_init(vkb_srv_table *dev, uint32_t emu) +{ + if (!emu) return; + vkb_emu_device *e = calloc(1, sizeof(*e)); + e->flags = emu; + e->dev = dev; + pthread_mutex_init(&e->lock, NULL); + dev->emu = e; + vkb_emu_install(dev); +} + +void vkb_emu_device_destroy(vkb_srv_table *dev) +{ + if (!dev->emu) return; + vkb_emu_uninstall(dev); + pthread_mutex_destroy(&dev->emu->lock); + free(dev->emu); + dev->emu = NULL; +} diff --git a/app/src/main/cpp/vkbridge/server_emu.h b/app/src/main/cpp/vkbridge/server_emu.h new file mode 100644 index 000000000..24395e817 --- /dev/null +++ b/app/src/main/cpp/vkbridge/server_emu.h @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later */ +#ifndef VKB_SERVER_EMU_H +#define VKB_SERVER_EMU_H + +#include "vkb_server.h" + +/* Emulations that are implemented (the rest are never offered to the client). */ +#ifndef VKB_EMU_IMPLEMENTED +#define VKB_EMU_IMPLEMENTED 0u +#endif + +typedef struct vkb_emu_device { + uint32_t flags; + vkb_srv_table *dev; + pthread_mutex_t lock; + void *bcn; /* server_emu_bcn.c state */ + void *shaders; /* server_emu_shader.c state */ +} vkb_emu_device; + +int vkb_emu_bcn_supported(const vkb_dispatch *idt, VkPhysicalDevice pd); +void vkb_emu_install(vkb_srv_table *dev); +void vkb_emu_uninstall(vkb_srv_table *dev); + +#endif diff --git a/app/src/main/cpp/vkbridge/server_emu_layer.c b/app/src/main/cpp/vkbridge/server_emu_layer.c new file mode 100644 index 000000000..d453d69a6 --- /dev/null +++ b/app/src/main/cpp/vkbridge/server_emu_layer.c @@ -0,0 +1,23 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Emulation wrappers installed into a device's dispatch table. + */ +#define _GNU_SOURCE +#include "server_emu.h" + +int vkb_emu_bcn_supported(const vkb_dispatch *idt, VkPhysicalDevice pd) +{ + (void)idt; + (void)pd; + return 0; +} + +void vkb_emu_install(vkb_srv_table *dev) +{ + (void)dev; +} + +void vkb_emu_uninstall(vkb_srv_table *dev) +{ + (void)dev; +} diff --git a/app/src/main/cpp/vkbridge/server_instance.c b/app/src/main/cpp/vkbridge/server_instance.c new file mode 100644 index 000000000..401f8b4a0 --- /dev/null +++ b/app/src/main/cpp/vkbridge/server_instance.c @@ -0,0 +1,323 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Instances, devices and the startup self-test. + */ +#define _GNU_SOURCE +#include "vkb_server.h" + +#include +#include +#include + +vkb_pd_knowledge vkb_pds[VKB_MAX_PDS]; +int vkb_npds; + +static int has_ext(const VkExtensionProperties *e, uint32_t n, const char *name) +{ + for (uint32_t i = 0; i < n; i++) + if (!strcmp(e[i].extensionName, name)) return 1; + return 0; +} + +const vkb_pd_knowledge *vkb_pd_lookup(const vkb_dispatch *dt, VkPhysicalDevice pd) +{ + VkPhysicalDeviceIDProperties id = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES}; + VkPhysicalDeviceProperties2 p2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, &id}; + if (!dt->vkGetPhysicalDeviceProperties2) return NULL; + dt->vkGetPhysicalDeviceProperties2(pd, &p2); + for (int i = 0; i < vkb_npds; i++) + if (vkb_pds[i].valid && !memcmp(vkb_pds[i].uuid, id.deviceUUID, VK_UUID_SIZE)) return &vkb_pds[i]; + return NULL; +} + +/* ------------------------------------------------------------------ startup self-test */ + +static void log_device(const vkb_dispatch *dt, VkPhysicalDevice pd, const VkPhysicalDeviceProperties *p) +{ + VKB_INFO("GPU: %s (vendor 0x%04x device 0x%04x, Vulkan %u.%u.%u, driver 0x%08x)", p->deviceName, + p->vendorID, p->deviceID, VK_API_VERSION_MAJOR(p->apiVersion), VK_API_VERSION_MINOR(p->apiVersion), + VK_API_VERSION_PATCH(p->apiVersion), p->driverVersion); + VkPhysicalDeviceFeatures f; + dt->vkGetPhysicalDeviceFeatures(pd, &f); +#define F(x) #x, f.x + VKB_INFO("features: %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u", F(textureCompressionBC), F(shaderClipDistance), + F(shaderCullDistance), F(geometryShader), F(tessellationShader), F(depthClamp), F(shaderFloat64), F(shaderInt64)); + VKB_INFO("features: %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u", F(multiViewport), F(independentBlend), F(logicOp), + F(fillModeNonSolid), F(dualSrcBlend), F(sampleRateShading), F(depthBiasClamp), F(wideLines)); + VKB_INFO("features: %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u", F(drawIndirectFirstInstance), F(multiDrawIndirect), + F(occlusionQueryPrecise), F(pipelineStatisticsQuery), F(vertexPipelineStoresAndAtomics), + F(fragmentStoresAndAtomics), F(shaderStorageImageWriteWithoutFormat), F(imageCubeArray)); + VKB_INFO("features: %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u", F(robustBufferAccess), F(fullDrawIndexUint32), F(samplerAnisotropy), + F(depthBounds), F(largePoints), F(shaderStorageImageExtendedFormats)); +#undef F + uint32_t n = 0; + dt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, NULL); + VkExtensionProperties *e = calloc(n ? n : 1, sizeof(*e)); + dt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, e); + static const char *const watch[] = { + "VK_EXT_depth_clip_enable", "VK_EXT_vertex_attribute_divisor", "VK_KHR_vertex_attribute_divisor", + "VK_EXT_external_memory_dma_buf", "VK_EXT_image_drm_format_modifier", "VK_KHR_external_memory_fd", + "VK_EXT_external_memory_host", "VK_ANDROID_external_memory_android_hardware_buffer", + "VK_KHR_external_semaphore_fd", "VK_KHR_external_fence_fd", "VK_EXT_queue_family_foreign", + "VK_EXT_robustness2", "VK_EXT_transform_feedback", "VK_EXT_custom_border_color", + "VK_EXT_mutable_descriptor_type", "VK_VALVE_mutable_descriptor_type", "VK_EXT_extended_dynamic_state3", + "VK_EXT_graphics_pipeline_library", "VK_EXT_physical_device_drm", "VK_KHR_push_descriptor", + "VK_EXT_descriptor_indexing", "VK_KHR_timeline_semaphore", "VK_EXT_memory_budget", + "VK_KHR_maintenance5", "VK_EXT_line_rasterization", "VK_EXT_provoking_vertex", + }; + char line[1024]; + size_t len = 0; + line[0] = 0; + for (size_t i = 0; i < sizeof(watch) / sizeof(watch[0]); i++) { + int ok = has_ext(e, n, watch[i]); + len += (size_t)snprintf(line + len, sizeof(line) - len, "%s%s%s", len ? " " : "", ok ? "+" : "-", watch[i] + 3); + if (len > 700 || i + 1 == sizeof(watch) / sizeof(watch[0])) { + VKB_INFO("extensions: %s", line); + len = 0; + line[0] = 0; + } + } + VKB_INFO("%u device extensions in total", n); + for (uint32_t i = 0; i < n; i++) VKB_DBG(" %s (rev %u)", e[i].extensionName, e[i].specVersion); + free(e); + VkPhysicalDeviceMemoryProperties mp; + dt->vkGetPhysicalDeviceMemoryProperties(pd, &mp); + for (uint32_t i = 0; i < mp.memoryHeapCount; i++) + VKB_INFO("memory heap %u: %llu MB flags 0x%x", i, (unsigned long long)(mp.memoryHeaps[i].size >> 20), mp.memoryHeaps[i].flags); + for (uint32_t i = 0; i < mp.memoryTypeCount; i++) + VKB_INFO("memory type %u: heap %u flags 0x%x", i, mp.memoryTypes[i].heapIndex, mp.memoryTypes[i].propertyFlags); +} + +void vkb_selftest_all(void) +{ + uint32_t api = VK_API_VERSION_1_0; + if (vkb_global_dt.vkEnumerateInstanceVersion) vkb_global_dt.vkEnumerateInstanceVersion(&api); + if (api > VK_API_VERSION_1_3) api = VK_API_VERSION_1_3; + VkApplicationInfo app = {VK_STRUCTURE_TYPE_APPLICATION_INFO, NULL, "vkbridge-selftest", 1, "vkbridge", 1, api}; + VkInstanceCreateInfo ci = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, NULL, 0, &app, 0, NULL, 0, NULL}; + VkInstance inst; + VkResult r = vkb_global_dt.vkCreateInstance(&ci, NULL, &inst); + if (r != VK_SUCCESS) { + VKB_ERR("self-test: vkCreateInstance failed (%d); the driver is unusable", r); + return; + } + vkb_dispatch dt; + vkb_dispatch_load_instance(&dt, vkb_gipa, inst); + uint32_t n = 0; + dt.vkEnumeratePhysicalDevices(inst, &n, NULL); + if (n > VKB_MAX_PDS) n = VKB_MAX_PDS; + VkPhysicalDevice pds[VKB_MAX_PDS]; + dt.vkEnumeratePhysicalDevices(inst, &n, pds); + VKB_INFO("self-test: loader Vulkan %u.%u, %u physical device(s)", VK_API_VERSION_MAJOR(api), VK_API_VERSION_MINOR(api), n); + for (uint32_t i = 0; i < n; i++) { + VkPhysicalDeviceIDProperties id = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES}; + VkPhysicalDeviceProperties2 p2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, &id}; + dt.vkGetPhysicalDeviceProperties2(pds[i], &p2); + log_device(&dt, pds[i], &p2.properties); + vkb_pd_knowledge *k = &vkb_pds[vkb_npds++]; + memcpy(k->uuid, id.deviceUUID, VK_UUID_SIZE); + snprintf(k->name, sizeof(k->name), "%s", p2.properties.deviceName); + k->info.real_api_version = p2.properties.apiVersion; + vkb_mem_selftest(k, inst, &dt, pds[i]); + k->info.emu_available = vkb_emu_detect(&dt, pds[i]); + k->info.emu = k->info.emu_available; + const char *emu_env = getenv("VKBRIDGE_EMULATE"); + if (emu_env && !strcmp(emu_env, "0")) k->info.emu = 0; + k->valid = 1; + VKB_INFO("%s: memory sharing = %s, emulating 0x%x", k->name, vkb_mem_strategy_name(k->info.strategy), k->info.emu); + } + dt.vkDestroyInstance(inst, NULL); +} + +/* ------------------------------------------------------------------ instance */ + +void vkb_sv_vkCreateInstance(vkb_srv_call *c) +{ + VkInstanceCreateInfo *ci = NULL; + if (vkb_dec_u8(&c->d)) { + ci = vkb_dec_alloc(&c->d, sizeof(*ci)); + if (ci) vkb_dec_VkInstanceCreateInfo(&c->d, ci); + } + uint8_t want_out = vkb_dec_u8(&c->d); + if (c->d.err || !ci || !want_out) { + 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; + if (r == VK_SUCCESS) { + vkb_srv_table *t = calloc(1, sizeof(*t)); + pthread_mutex_init(&t->lock, NULL); + t->instance = inst; + t->proc = c->conn->proc; + t->api_version = ci->pApplicationInfo ? ci->pApplicationInfo->apiVersion : VK_API_VERSION_1_0; + vkb_dispatch_load_instance(&t->real, vkb_gipa, inst); + t->dt = t->real; + id = vkb_table_register(t); + if (!id) { + t->real.vkDestroyInstance(inst, NULL); + free(t); + r = VK_ERROR_OUT_OF_HOST_MEMORY; + inst = VK_NULL_HANDLE; + } else { + VKB_INFO("instance %u created (app \"%s\", engine \"%s\", Vulkan %u.%u)", id, + ci->pApplicationInfo && ci->pApplicationInfo->pApplicationName ? ci->pApplicationInfo->pApplicationName : "", + ci->pApplicationInfo && ci->pApplicationInfo->pEngineName ? ci->pApplicationInfo->pEngineName : "", + VK_API_VERSION_MAJOR(t->api_version), VK_API_VERSION_MINOR(t->api_version)); + } + } else { + VKB_ERR("vkCreateInstance failed: %d", r); + } + vkb_enc_u32(&c->r, (uint32_t)r); + vkb_enc_u64(&c->r, (uint64_t)(uintptr_t)inst); + vkb_enc_u32(&c->r, id); +} + +void vkb_sv_vkDestroyInstance(vkb_srv_call *c) +{ + VkInstance inst = (VkInstance)(uintptr_t)vkb_dec_u64(&c->d); + vkb_srv_table *t = c->table; + if (!t || t->is_device || t->instance != inst) { + vkb_srv_bad_message(c); + return; + } + vkb_table_unregister(t); + t->real.vkDestroyInstance(inst, NULL); + pthread_mutex_destroy(&t->lock); + free(t); + c->table = NULL; +} + +void vkb_sv_vkbQueryServer(vkb_srv_call *c) +{ + VkPhysicalDevice pd = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(&c->d); + if (c->d.err || !c->table) { + vkb_srv_bad_message(c); + return; + } + const vkb_pd_knowledge *k = vkb_pd_lookup(c->dt, pd); + vkb_server_pd_info info; + memset(&info, 0, sizeof(info)); + if (k) info = k->info; + else VKB_WARN("query for a physical device the self-test did not see"); + vkb_enc_raw(&c->r, &info, sizeof(info)); +} + +/* ------------------------------------------------------------------ device */ + +static int list_has(const char *const *l, uint32_t n, const char *s) +{ + for (uint32_t i = 0; i < n; i++) + if (l[i] && !strcmp(l[i], s)) return 1; + return 0; +} + +void vkb_sv_vkCreateDevice(vkb_srv_call *c) +{ + VkPhysicalDevice pd = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(&c->d); + VkDeviceCreateInfo *ci = NULL; + if (vkb_dec_u8(&c->d)) { + ci = vkb_dec_alloc(&c->d, sizeof(*ci)); + if (ci) vkb_dec_VkDeviceCreateInfo(&c->d, ci); + } + uint8_t want_out = vkb_dec_u8(&c->d); + vkb_srv_table *inst = c->table; + if (c->d.err || !ci || !want_out || !inst || inst->is_device) { + vkb_srv_bad_message(c); + return; + } + const vkb_pd_knowledge *k = vkb_pd_lookup(&inst->real, pd); + uint32_t strategy = k ? k->info.strategy : VKB_MEM_NONE; + uint32_t emu = k ? k->info.emu : 0; + + /* Extensions the server itself needs (memory sharing), when the driver has them. */ + uint32_t avail_n = 0; + inst->real.vkEnumerateDeviceExtensionProperties(pd, NULL, &avail_n, NULL); + VkExtensionProperties *avail = vkb_dec_alloc(&c->d, (avail_n ? avail_n : 1) * sizeof(*avail)); + inst->real.vkEnumerateDeviceExtensionProperties(pd, NULL, &avail_n, avail); + uint32_t extra_n = 0; + const char *const *extra = vkb_mem_required_extensions(strategy, &extra_n); + const char **exts = vkb_dec_alloc(&c->d, (ci->enabledExtensionCount + extra_n + 1) * sizeof(char *)); + uint32_t n = 0; + for (uint32_t i = 0; i < ci->enabledExtensionCount; i++) { + const char *e = ci->ppEnabledExtensionNames[i]; + if (!has_ext(avail, avail_n, e)) { + VKB_DBG("device extension %s is emulated or client-side; not passed to the driver", e); + continue; + } + exts[n++] = e; + } + for (uint32_t i = 0; i < extra_n; i++) + if (has_ext(avail, avail_n, extra[i]) && !list_has(exts, n, extra[i])) exts[n++] = extra[i]; + ci->enabledExtensionCount = n; + ci->ppEnabledExtensionNames = exts; + ci->enabledLayerCount = 0; + ci->ppEnabledLayerNames = NULL; + + vkb_emu_device_create_info(inst, pd, emu, ci, c->d.arena); + + VkDevice dev = VK_NULL_HANDLE; + VkResult r = inst->real.vkCreateDevice(pd, ci, NULL, &dev); + uint32_t id = 0; + if (r == VK_SUCCESS) { + vkb_srv_table *t = calloc(1, sizeof(*t)); + pthread_mutex_init(&t->lock, NULL); + t->is_device = 1; + t->proc = c->conn->proc; + t->instance = inst->instance; + t->device = dev; + t->physical = pd; + t->parent = inst; + t->pd = k; + t->api_version = inst->api_version; + t->real = inst->real; + PFN_vkGetDeviceProcAddr gdpa = (PFN_vkGetDeviceProcAddr)vkb_gipa(inst->instance, "vkGetDeviceProcAddr"); + vkb_dispatch_load_device(&t->real, gdpa, dev); + t->dt = t->real; + id = vkb_table_register(t); + if (!id) { + t->real.vkDestroyDevice(dev, NULL); + free(t); + dev = VK_NULL_HANDLE; + r = VK_ERROR_OUT_OF_HOST_MEMORY; + } else { + vkb_emu_device_init(t, emu); + VKB_INFO("device %u created on %s (%u extensions, memory sharing %s)", id, k ? k->name : "?", n, + vkb_mem_strategy_name(strategy)); + for (uint32_t i = 0; i < n; i++) VKB_DBG(" device extension %s", exts[i]); + } + } else { + VKB_ERR("vkCreateDevice failed: %d (%u extensions)", r, n); + for (uint32_t i = 0; i < n; i++) VKB_ERR(" requested %s", exts[i]); + } + vkb_enc_u32(&c->r, (uint32_t)r); + vkb_enc_u64(&c->r, (uint64_t)(uintptr_t)dev); + vkb_enc_u32(&c->r, id); +} + +void vkb_sv_vkDestroyDevice(vkb_srv_call *c) +{ + VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d); + vkb_srv_table *t = c->table; + if (!t || !t->is_device || t->device != dev) { + vkb_srv_bad_message(c); + return; + } + vkb_table_unregister(t); + vkb_emu_device_destroy(t); + vkb_mem_free_all(t); + t->real.vkDestroyDevice(dev, NULL); + VKB_INFO("device %u destroyed", t->id); + pthread_mutex_destroy(&t->lock); + free(t); + c->table = NULL; +} diff --git a/app/src/main/cpp/vkbridge/server_main.c b/app/src/main/cpp/vkbridge/server_main.c new file mode 100644 index 000000000..59c665130 --- /dev/null +++ b/app/src/main/cpp/vkbridge/server_main.c @@ -0,0 +1,180 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * vkbridge server entry point. + * + * libvkbridge_server.so --socket [--log ] [--vulkan ] [--selftest] + * + * Packaged as a "library" so Android extracts it into the native library directory, from where + * the app executes it like proot. It loads the system Vulkan loader (on the device: the vendor's + * Mali driver behind /system/lib64/libvulkan.so), runs a self-test that decides how mapped memory + * is shared with the Linux side, then serves the session's Vulkan calls until it is killed or its + * parent dies. + */ +#define _GNU_SOURCE +#include "vkb_server.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __ANDROID__ +#include +#endif + +PFN_vkGetInstanceProcAddr vkb_gipa; +vkb_dispatch vkb_global_dt; +int vkb_verbose; + +static FILE *log_file; +static int log_level = VKB_LOG_INFO; +static pthread_mutex_t log_lock = PTHREAD_MUTEX_INITIALIZER; + +int vkb_log_level(void) { return log_level; } + +void vkb_log(int level, const char *fmt, ...) +{ + if (level > log_level) return; + char msg[2048]; + va_list ap; + va_start(ap, fmt); + vsnprintf(msg, sizeof(msg), fmt, ap); + va_end(ap); + static const char *const tags[] = {"E", "W", "I", "D"}; + struct timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + struct tm tm; + localtime_r(&ts.tv_sec, &tm); + pthread_mutex_lock(&log_lock); + FILE *f = log_file ? log_file : stderr; + fprintf(f, "%02d:%02d:%02d.%03ld vkbridge-server %s %s\n", tm.tm_hour, tm.tm_min, tm.tm_sec, + ts.tv_nsec / 1000000, tags[level & 3], msg); + fflush(f); + pthread_mutex_unlock(&log_lock); +#ifdef __ANDROID__ + static const int prio[] = {ANDROID_LOG_ERROR, ANDROID_LOG_WARN, ANDROID_LOG_INFO, ANDROID_LOG_DEBUG}; + __android_log_write(prio[level & 3], "vkbridge", msg); +#endif +} + +static void *load_vulkan(const char *override) +{ + const char *names[] = { + override, +#ifdef __ANDROID__ + "libvulkan.so", +#else + "libvulkan.so.1", + "libvulkan.so", +#endif + }; + for (size_t i = 0; i < sizeof(names) / sizeof(names[0]); i++) { + if (!names[i]) continue; + void *h = dlopen(names[i], RTLD_NOW | RTLD_LOCAL); + if (h) { + VKB_INFO("Vulkan loader: %s", names[i]); + return h; + } + VKB_WARN("cannot open %s: %s", names[i], dlerror()); + } + return NULL; +} + +static int listen_on(const char *path) +{ + struct sockaddr_un a; + if (strlen(path) >= sizeof(a.sun_path)) { + VKB_ERR("socket path too long (%zu bytes): %s", strlen(path), path); + return -1; + } + int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); + if (fd < 0) { + VKB_ERR("socket: %s", strerror(errno)); + return -1; + } + memset(&a, 0, sizeof(a)); + a.sun_family = AF_UNIX; + strcpy(a.sun_path, path); + unlink(path); + if (bind(fd, (struct sockaddr *)&a, sizeof(a)) < 0) { + VKB_ERR("bind %s: %s", path, strerror(errno)); + close(fd); + return -1; + } + chmod(path, 0600); + if (listen(fd, 128) < 0) { + VKB_ERR("listen: %s", strerror(errno)); + close(fd); + return -1; + } + return fd; +} + +static void usage(void) +{ + fprintf(stderr, "usage: vkbridge-server --socket PATH [--log FILE] [--vulkan LIB] [--selftest] [--verbose]\n"); +} + +int main(int argc, char **argv) +{ + const char *sock_path = getenv("VKBRIDGE_SOCKET"); + const char *log_path = getenv("VKBRIDGE_SERVER_LOG"); + const char *vk_lib = getenv("VKBRIDGE_SERVER_VULKAN"); + int selftest_only = 0; + for (int i = 1; i < argc; i++) { + if (!strcmp(argv[i], "--socket") && i + 1 < argc) sock_path = argv[++i]; + else if (!strcmp(argv[i], "--log") && i + 1 < argc) log_path = argv[++i]; + else if (!strcmp(argv[i], "--vulkan") && i + 1 < argc) vk_lib = argv[++i]; + else if (!strcmp(argv[i], "--selftest")) selftest_only = 1; + else if (!strcmp(argv[i], "--verbose")) vkb_verbose = 1; + else { + usage(); + return 2; + } + } + if (getenv("VKBRIDGE_DEBUG")) vkb_verbose = 1; + if (vkb_verbose) log_level = VKB_LOG_DEBUG; + if (log_path) { + log_file = fopen(log_path, "ae"); + if (!log_file) fprintf(stderr, "vkbridge-server: cannot open log %s: %s\n", log_path, strerror(errno)); + } + signal(SIGPIPE, SIG_IGN); + /* The server is the app's child: when the app dies, so does the session's GPU. */ + prctl(PR_SET_PDEATHSIG, SIGTERM); + + VKB_INFO("starting (pid %d, protocol %016llx)", getpid(), (unsigned long long)VKB_PROTOCOL_HASH); + void *lib = load_vulkan(vk_lib); + if (!lib) { + VKB_ERR("no Vulkan loader; nothing to serve"); + return 1; + } + vkb_gipa = (PFN_vkGetInstanceProcAddr)dlsym(lib, "vkGetInstanceProcAddr"); + if (!vkb_gipa) { + VKB_ERR("the Vulkan loader exports no vkGetInstanceProcAddr"); + return 1; + } + vkb_dispatch_load_instance(&vkb_global_dt, vkb_gipa, VK_NULL_HANDLE); + + vkb_selftest_all(); + if (selftest_only) return vkb_npds > 0 ? 0 : 1; + + if (!sock_path) { + usage(); + return 2; + } + int lfd = listen_on(sock_path); + if (lfd < 0) return 1; + VKB_INFO("listening on %s", sock_path); + vkb_srv_serve(lfd); + return 0; +} diff --git a/app/src/main/cpp/vkbridge/server_memory.c b/app/src/main/cpp/vkbridge/server_memory.c new file mode 100644 index 000000000..f80313162 --- /dev/null +++ b/app/src/main/cpp/vkbridge/server_memory.c @@ -0,0 +1,667 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Host-visible memory shared with the client. + * + * A Linux program maps Vulkan memory and writes to it directly; those writes must land in the + * pages the GPU reads. The server makes such memory shareable in one of three ways, chosen per + * GPU by a self-test at startup that checks the GPU and both CPU mappings really see the same + * bytes: + * hostptr the client creates a memfd, the server maps it and imports it + * (VK_EXT_external_memory_host); + * dmabuf the server allocates exportable memory and hands the client its dma-buf + * (VK_EXT_external_memory_dma_buf), which the client maps; + * ahb the server allocates a BLOB AHardwareBuffer, imports it, and hands the client the + * dma-buf behind it (Android only). + * VKBRIDGE_MEMORY=hostptr|dmabuf|ahb forces one. + */ +#define _GNU_SOURCE +#ifdef __ANDROID__ +#define VK_USE_PLATFORM_ANDROID_KHR 1 +#endif +#include "vkb_server.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __ANDROID__ +#include +/* libnativewindow, opened at run time (getNativeHandle is not in the NDK headers). */ +typedef struct { + uint32_t width, height, layers, format; + uint64_t usage; + uint32_t stride, rfu0; + uint64_t rfu1; +} vkb_ahb_desc; +typedef struct { + int version, numFds, numInts; + int data[0]; +} vkb_native_handle; +static int (*p_AHardwareBuffer_allocate)(const vkb_ahb_desc *, struct AHardwareBuffer **); +static void (*p_AHardwareBuffer_release)(struct AHardwareBuffer *); +static const vkb_native_handle *(*p_AHardwareBuffer_getNativeHandle)(const struct AHardwareBuffer *); +#define AHB_FORMAT_BLOB 0x21 +#define AHB_USAGE_CPU_READ_OFTEN 3ull +#define AHB_USAGE_CPU_WRITE_OFTEN (3ull << 4) +#define AHB_USAGE_GPU_DATA_BUFFER (1ull << 24) + +static int ahb_load(void) +{ + static int state; + if (state) return state > 0; + void *h = dlopen("libnativewindow.so", RTLD_NOW); + if (!h) h = dlopen("libandroid.so", RTLD_NOW); + if (h) { + p_AHardwareBuffer_allocate = dlsym(h, "AHardwareBuffer_allocate"); + p_AHardwareBuffer_release = dlsym(h, "AHardwareBuffer_release"); + p_AHardwareBuffer_getNativeHandle = dlsym(h, "AHardwareBuffer_getNativeHandle"); + } + state = (p_AHardwareBuffer_allocate && p_AHardwareBuffer_release && p_AHardwareBuffer_getNativeHandle) ? 1 : -1; + if (state < 0) VKB_WARN("AHardwareBuffer functions unavailable"); + return state > 0; +} +#endif + +static const char *const ext_hostptr[] = {"VK_KHR_external_memory", "VK_EXT_external_memory_host"}; +static const char *const ext_dmabuf[] = {"VK_KHR_external_memory", "VK_KHR_external_memory_fd", "VK_EXT_external_memory_dma_buf"}; +#ifdef __ANDROID__ +static const char *const ext_ahb[] = {"VK_KHR_external_memory", "VK_ANDROID_external_memory_android_hardware_buffer", + "VK_EXT_queue_family_foreign", "VK_KHR_sampler_ycbcr_conversion", + "VK_KHR_dedicated_allocation", "VK_KHR_get_memory_requirements2"}; +#endif + +const char *const *vkb_mem_required_extensions(uint32_t strategy, uint32_t *count) +{ + switch (strategy) { + case VKB_MEM_HOSTPTR: *count = 2; return ext_hostptr; + case VKB_MEM_DMABUF: *count = 3; return ext_dmabuf; +#ifdef __ANDROID__ + case VKB_MEM_AHB: *count = 6; return ext_ahb; +#endif + default: *count = 0; return NULL; + } +} + +static uint32_t strategy_handle_type(uint32_t s) +{ + switch (s) { + case VKB_MEM_HOSTPTR: return VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT; + case VKB_MEM_DMABUF: return VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT; +#ifdef __ANDROID__ + case VKB_MEM_AHB: return VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID; +#endif + default: return 0; + } +} + +int vkb_memfd(const char *name, size_t size) +{ + int fd = (int)syscall(SYS_memfd_create, name, 1u /* MFD_CLOEXEC */); + if (fd < 0) return -1; + if (ftruncate(fd, (off_t)size) < 0) { + close(fd); + return -1; + } + return fd; +} + +/* ------------------------------------------------------------------ tracking */ + +static unsigned mem_hash(VkDeviceMemory m) +{ + uint64_t v = (uint64_t)(uintptr_t)m; + v ^= v >> 17; + v *= 0x9E3779B97F4A7C15ull; + return (unsigned)(v >> 56); +} + +void vkb_mem_track(vkb_srv_table *dev, vkb_srv_mem *m) +{ + pthread_mutex_lock(&dev->lock); + unsigned h = mem_hash(m->mem); + m->next = dev->mems[h]; + dev->mems[h] = m; + pthread_mutex_unlock(&dev->lock); +} + +vkb_srv_mem *vkb_mem_find(vkb_srv_table *dev, VkDeviceMemory mem, int remove) +{ + pthread_mutex_lock(&dev->lock); + vkb_srv_mem **pp = &dev->mems[mem_hash(mem)]; + while (*pp && (*pp)->mem != mem) pp = &(*pp)->next; + vkb_srv_mem *m = *pp; + if (m && remove) *pp = m->next; + pthread_mutex_unlock(&dev->lock); + return m; +} + +/* Frees the server-side resources of an allocation (the VkDeviceMemory must already be freed). */ +static void mem_release_backing(vkb_srv_mem *m) +{ + if (m->host_ptr) munmap(m->host_ptr, m->host_len); +#ifdef __ANDROID__ + if (m->ahb) p_AHardwareBuffer_release(m->ahb); +#endif + free(m); +} + +void vkb_mem_release(vkb_srv_table *dev, vkb_srv_mem *m) +{ + if (m->mapped) dev->real.vkUnmapMemory(dev->device, m->mem); + dev->real.vkFreeMemory(dev->device, m->mem, NULL); + mem_release_backing(m); +} + +void vkb_mem_free_all(vkb_srv_table *dev) +{ + for (int i = 0; i < 256; i++) { + vkb_srv_mem *m = dev->mems[i]; + dev->mems[i] = NULL; + while (m) { + vkb_srv_mem *n = m->next; + vkb_mem_release(dev, m); + m = n; + } + } +} + +/* ------------------------------------------------------------------ allocation */ + +/* + * Allocates shared memory with strategy `s`. `ai` is the app's (or the self-test's) allocate + * info; for hostptr, `client_fd` is the client's memfd (consumed). On success *out_fd is the fd + * to send to the client (-1 for hostptr, where the client already has its pages). + */ +static VkResult alloc_shared(const vkb_dispatch *dt, VkDevice dev, uint32_t s, const VkMemoryAllocateInfo *ai, + int client_fd, vkb_srv_mem **out, int *out_fd) +{ + *out_fd = -1; + *out = NULL; + vkb_srv_mem *m = calloc(1, sizeof(*m)); + if (!m) { + if (client_fd >= 0) close(client_fd); + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + m->size = ai->allocationSize; + m->type = ai->memoryTypeIndex; + m->strategy = s; + VkMemoryAllocateInfo info = *ai; + VkResult r = VK_ERROR_FEATURE_NOT_PRESENT; + switch (s) { + case VKB_MEM_HOSTPTR: { + if (client_fd < 0) break; + void *p = mmap(NULL, (size_t)ai->allocationSize, PROT_READ | PROT_WRITE, MAP_SHARED, client_fd, 0); + close(client_fd); + client_fd = -1; + if (p == MAP_FAILED) { + VKB_ERR("hostptr: mmap of the client's memory failed: %s", strerror(errno)); + r = VK_ERROR_OUT_OF_HOST_MEMORY; + break; + } + m->host_ptr = p; + m->host_len = (size_t)ai->allocationSize; + VkMemoryHostPointerPropertiesEXT hp = {VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT}; + if (!dt->vkGetMemoryHostPointerPropertiesEXT || + dt->vkGetMemoryHostPointerPropertiesEXT(dev, VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, p, &hp) != VK_SUCCESS || + !(hp.memoryTypeBits & (1u << ai->memoryTypeIndex))) { + r = VK_ERROR_INVALID_EXTERNAL_HANDLE; + break; + } + VkImportMemoryHostPointerInfoEXT imp = {VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, info.pNext, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, p}; + info.pNext = &imp; + r = dt->vkAllocateMemory(dev, &info, NULL, &m->mem); + break; + } + case VKB_MEM_DMABUF: { + VkExportMemoryAllocateInfo exp = {VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, info.pNext, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT}; + /* An export the app asked for itself is merged rather than duplicated. */ + for (VkBaseOutStructure *b = (VkBaseOutStructure *)info.pNext; b; b = b->pNext) { + if (b->sType == VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO) { + ((VkExportMemoryAllocateInfo *)b)->handleTypes |= VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT; + exp.sType = VK_STRUCTURE_TYPE_MAX_ENUM; + } + } + if (exp.sType != VK_STRUCTURE_TYPE_MAX_ENUM) info.pNext = &exp; + r = dt->vkAllocateMemory(dev, &info, NULL, &m->mem); + if (r != VK_SUCCESS) break; + VkMemoryGetFdInfoKHR gi = {VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, NULL, m->mem, VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT}; + int fd = -1; + if (!dt->vkGetMemoryFdKHR || dt->vkGetMemoryFdKHR(dev, &gi, &fd) != VK_SUCCESS || fd < 0) { + dt->vkFreeMemory(dev, m->mem, NULL); + m->mem = VK_NULL_HANDLE; + r = VK_ERROR_INVALID_EXTERNAL_HANDLE; + break; + } + *out_fd = fd; + break; + } +#ifdef __ANDROID__ + case VKB_MEM_AHB: { + if (!ahb_load()) break; + static PFN_vkGetAndroidHardwareBufferPropertiesANDROID get_props; + if (!get_props) { + PFN_vkGetDeviceProcAddr gdpa = (PFN_vkGetDeviceProcAddr)vkb_gipa(VK_NULL_HANDLE, "vkGetDeviceProcAddr"); + if (gdpa) get_props = (PFN_vkGetAndroidHardwareBufferPropertiesANDROID)gdpa(dev, "vkGetAndroidHardwareBufferPropertiesANDROID"); + } + if (!get_props) break; + uint64_t sz = ai->allocationSize; + if (sz > 0xFFFFFFFFull) { + r = VK_ERROR_OUT_OF_DEVICE_MEMORY; + break; + } + vkb_ahb_desc d = {(uint32_t)sz, 1, 1, AHB_FORMAT_BLOB, + AHB_USAGE_CPU_READ_OFTEN | AHB_USAGE_CPU_WRITE_OFTEN | AHB_USAGE_GPU_DATA_BUFFER, 0, 0, 0}; + struct AHardwareBuffer *ahb = NULL; + if (p_AHardwareBuffer_allocate(&d, &ahb) != 0 || !ahb) { + r = VK_ERROR_OUT_OF_DEVICE_MEMORY; + break; + } + m->ahb = ahb; + VkAndroidHardwareBufferPropertiesANDROID props = {VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID}; + if (get_props(dev, ahb, &props) != VK_SUCCESS || !(props.memoryTypeBits & (1u << ai->memoryTypeIndex))) { + r = VK_ERROR_INVALID_EXTERNAL_HANDLE; + break; + } + VkImportAndroidHardwareBufferInfoANDROID imp = {VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, info.pNext, ahb}; + info.pNext = &imp; + info.allocationSize = props.allocationSize; + r = dt->vkAllocateMemory(dev, &info, NULL, &m->mem); + if (r != VK_SUCCESS) break; + const vkb_native_handle *nh = p_AHardwareBuffer_getNativeHandle(ahb); + if (!nh || nh->numFds < 1) { + dt->vkFreeMemory(dev, m->mem, NULL); + m->mem = VK_NULL_HANDLE; + r = VK_ERROR_INVALID_EXTERNAL_HANDLE; + break; + } + *out_fd = fcntl(nh->data[0], F_DUPFD_CLOEXEC, 0); + break; + } +#endif + default: + break; + } + if (client_fd >= 0) close(client_fd); + if (r != VK_SUCCESS) { + mem_release_backing(m); + return r; + } + *out = m; + return VK_SUCCESS; +} + +/* ------------------------------------------------------------------ handlers */ + +static void close_import_fds(const void *pNext) +{ + for (const VkBaseInStructure *b = pNext; b; b = b->pNext) + if (b->sType == VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR) vkb_close_fd(((const VkImportMemoryFdInfoKHR *)b)->fd); +} + +void vkb_sv_vkAllocateMemory(vkb_srv_call *c) +{ + VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d); + VkMemoryAllocateInfo ai; + int have = vkb_dec_u8(&c->d); + if (have) vkb_dec_VkMemoryAllocateInfo(&c->d, &ai); + uint32_t mode = vkb_dec_u32(&c->d); + int client_fd = vkb_dec_fd(&c->d); + vkb_srv_table *t = c->table; + if (c->d.err || !have || !t || !t->is_device || t->device != dev) { + if (client_fd >= 0) close(client_fd); + vkb_srv_bad_message(c); + return; + } + VkResult r; + vkb_srv_mem *m = NULL; + int out_fd = -1; + if (mode == VKB_ALLOC_SHARED) { + uint32_t s = t->pd ? t->pd->info.strategy : VKB_MEM_NONE; + r = alloc_shared(c->dt, dev, s, &ai, client_fd, &m, &out_fd); + if (r != VK_SUCCESS) VKB_WARN("shared allocation of %llu bytes (type %u, %s) failed: %d", + (unsigned long long)ai.allocationSize, ai.memoryTypeIndex, vkb_mem_strategy_name(s), r); + } else { + if (client_fd >= 0) close(client_fd); + m = calloc(1, sizeof(*m)); + m->size = ai.allocationSize; + m->type = ai.memoryTypeIndex; + r = c->dt->vkAllocateMemory(dev, &ai, NULL, &m->mem); + if (r != VK_SUCCESS) { + close_import_fds(ai.pNext); + free(m); + m = NULL; + } + } + if (m) vkb_mem_track(t, m); + vkb_enc_u32(&c->r, (uint32_t)r); + vkb_enc_u64(&c->r, m ? (uint64_t)(uintptr_t)m->mem : 0); + vkb_enc_fd(&c->r, out_fd); + if (out_fd >= 0) vkb_srv_close_after_send(c, out_fd); + vkb_enc_u64(&c->r, m ? (uint64_t)m->size : 0); +} + +void vkb_sv_vkFreeMemory(vkb_srv_call *c) +{ + VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d); + VkDeviceMemory mem; + vkb_dec_bytes(&c->d, &mem, sizeof(mem)); + vkb_srv_table *t = c->table; + if (c->d.err || !t || !t->is_device || t->device != dev) { + vkb_srv_bad_message(c); + return; + } + if (!mem) return; + vkb_srv_mem *m = vkb_mem_find(t, mem, 1); + if (m) { + vkb_mem_release(t, m); + } else { + VKB_WARN("vkFreeMemory of untracked memory"); + c->dt->vkFreeMemory(dev, mem, NULL); + } +} + +static VkResult ensure_server_map(vkb_srv_table *t, vkb_srv_mem *m) +{ + if (m->mapped) return VK_SUCCESS; + pthread_mutex_lock(&t->lock); + VkResult r = VK_SUCCESS; + if (!m->mapped) r = t->real.vkMapMemory(t->device, m->mem, 0, VK_WHOLE_SIZE, 0, &m->mapped); + pthread_mutex_unlock(&t->lock); + return r; +} + +static void flush_or_invalidate(vkb_srv_call *c, int flush) +{ + VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d); + uint32_t n = vkb_dec_u32(&c->d); + vkb_srv_table *t = c->table; + if (c->d.err || !t || !t->is_device || t->device != dev || n > 65536) { + vkb_srv_bad_message(c); + return; + } + VkMappedMemoryRange *ranges = vkb_dec_alloc(&c->d, (n ? n : 1) * sizeof(*ranges)); + for (uint32_t i = 0; ranges && i < n; i++) vkb_dec_VkMappedMemoryRange(&c->d, &ranges[i]); + if (c->d.err) { + vkb_srv_bad_message(c); + return; + } + VkResult r = VK_SUCCESS; + for (uint32_t i = 0; i < n && r == VK_SUCCESS; i++) { + vkb_srv_mem *m = vkb_mem_find(t, ranges[i].memory, 0); + if (m) r = ensure_server_map(t, m); + } + if (r == VK_SUCCESS && n) { + r = flush ? c->dt->vkFlushMappedMemoryRanges(dev, n, ranges) : c->dt->vkInvalidateMappedMemoryRanges(dev, n, ranges); + } + vkb_enc_u32(&c->r, (uint32_t)r); +} + +void vkb_sv_vkFlushMappedMemoryRanges(vkb_srv_call *c) { flush_or_invalidate(c, 1); } +void vkb_sv_vkInvalidateMappedMemoryRanges(vkb_srv_call *c) { flush_or_invalidate(c, 0); } + +/* ------------------------------------------------------------------ self-test */ + +typedef struct { + const vkb_dispatch *idt; + vkb_dispatch dt; + VkPhysicalDevice pd; + VkDevice dev; + VkQueue queue; + VkCommandPool pool; + uint32_t qf; + VkPhysicalDeviceMemoryProperties mp; + VkDeviceSize import_align; +} selftest; + +static int submit_and_wait(selftest *st, VkCommandBuffer cb) +{ + VkFenceCreateInfo fci = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; + VkFence f; + if (st->dt.vkCreateFence(st->dev, &fci, NULL, &f) != VK_SUCCESS) return 0; + VkSubmitInfo si = {VK_STRUCTURE_TYPE_SUBMIT_INFO, NULL, 0, NULL, NULL, 1, &cb, 0, NULL}; + int ok = st->dt.vkQueueSubmit(st->queue, 1, &si, f) == VK_SUCCESS && + st->dt.vkWaitForFences(st->dev, 1, &f, VK_TRUE, 5000000000ull) == VK_SUCCESS; + st->dt.vkDestroyFence(st->dev, f, NULL); + return ok; +} + +#define TEST_SIZE (256u * 1024u) + +/* One allocation of `type` with strategy `s`, checked from both sides. 1 = shared and coherent + * (no flush needed), 2 = shared when flushed, 0 = not shared. */ +static int test_type(selftest *st, uint32_t s, uint32_t type) +{ + const vkb_dispatch *dt = &st->dt; + int result = 0; + VkExternalMemoryBufferCreateInfo ext = {VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, NULL, strategy_handle_type(s)}; + VkBufferCreateInfo bci = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, &ext, 0, TEST_SIZE, + VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, + VK_SHARING_MODE_EXCLUSIVE, 0, NULL}; + VkBuffer buf = VK_NULL_HANDLE; + if (dt->vkCreateBuffer(st->dev, &bci, NULL, &buf) != VK_SUCCESS) return 0; + VkMemoryRequirements req; + dt->vkGetBufferMemoryRequirements(st->dev, buf, &req); + if (!(req.memoryTypeBits & (1u << type))) { + dt->vkDestroyBuffer(st->dev, buf, NULL); + return 0; + } + VkDeviceSize size = req.size; + if (s == VKB_MEM_HOSTPTR) size = (size + st->import_align - 1) & ~(st->import_align - 1); + VkMemoryAllocateInfo ai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, NULL, size, type}; + int cfd = -1; + if (s == VKB_MEM_HOSTPTR) { + cfd = vkb_memfd("vkbridge-selftest", (size_t)size); + if (cfd < 0) { + dt->vkDestroyBuffer(st->dev, buf, NULL); + return 0; + } + } + int keep_fd = s == VKB_MEM_HOSTPTR ? fcntl(cfd, F_DUPFD_CLOEXEC, 0) : -1; + vkb_srv_mem *m = NULL; + int out_fd = -1; + VkResult r = alloc_shared(dt, st->dev, s, &ai, cfd, &m, &out_fd); + if (r != VK_SUCCESS) { + VKB_INFO(" %s, type %u: allocation failed (%d)", vkb_mem_strategy_name(s), type, r); + if (keep_fd >= 0) close(keep_fd); + dt->vkDestroyBuffer(st->dev, buf, NULL); + return 0; + } + int map_fd = s == VKB_MEM_HOSTPTR ? keep_fd : out_fd; + uint8_t *cmap = mmap(NULL, (size_t)m->size, PROT_READ | PROT_WRITE, MAP_SHARED, map_fd, 0); + if (map_fd >= 0) close(map_fd); + void *smap = NULL; + if (cmap == MAP_FAILED) { + VKB_INFO(" %s, type %u: the client cannot map the memory (%s)", vkb_mem_strategy_name(s), type, strerror(errno)); + cmap = NULL; + goto out; + } + if (dt->vkBindBufferMemory(st->dev, buf, m->mem, 0) != VK_SUCCESS || + dt->vkMapMemory(st->dev, m->mem, 0, VK_WHOLE_SIZE, 0, &smap) != VK_SUCCESS) { + VKB_INFO(" %s, type %u: bind/map failed", vkb_mem_strategy_name(s), type); + goto out; + } + int coherent = (st->mp.memoryTypes[type].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0; + VkMappedMemoryRange whole = {VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, NULL, m->mem, 0, VK_WHOLE_SIZE}; + + /* 1: the two CPU mappings are the same pages. */ + for (uint32_t i = 0; i < TEST_SIZE / 4; i += 997) ((volatile uint32_t *)cmap)[i] = 0x11220000u + i; + __sync_synchronize(); + for (uint32_t i = 0; i < TEST_SIZE / 4; i += 997) { + if (((volatile uint32_t *)smap)[i] != 0x11220000u + i) { + VKB_INFO(" %s, type %u: CPU mappings differ at word %u", vkb_mem_strategy_name(s), type, i); + goto out; + } + } + /* 2: GPU writes, client reads. 3: client writes, GPU copies, client reads the copy. */ + for (uint32_t i = TEST_SIZE / 8; i < TEST_SIZE / 8 + TEST_SIZE / 32; i++) ((volatile uint32_t *)cmap)[i] = 0x5a000000u ^ (i * 2654435761u); + if (!coherent) dt->vkFlushMappedMemoryRanges(st->dev, 1, &whole); + VkCommandBufferAllocateInfo cai = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, NULL, st->pool, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1}; + VkCommandBuffer cb; + if (dt->vkAllocateCommandBuffers(st->dev, &cai, &cb) != VK_SUCCESS) goto out; + VkCommandBufferBeginInfo bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, NULL}; + dt->vkBeginCommandBuffer(cb, &bi); + dt->vkCmdFillBuffer(cb, buf, 0, TEST_SIZE / 8, 0xA5A5A5A5u); + /* Layout (bytes): [0, N/8) GPU fill; [N/2, N/2 + N/8) written by the client and copied by + * the GPU to [3N/4, 3N/4 + N/8). */ + VkBufferCopy region = {TEST_SIZE / 2, TEST_SIZE / 4 * 3, TEST_SIZE / 8}; + dt->vkCmdCopyBuffer(cb, buf, buf, 1, ®ion); + VkMemoryBarrier mb = {VK_STRUCTURE_TYPE_MEMORY_BARRIER, NULL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT}; + dt->vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &mb, 0, NULL, 0, NULL); + dt->vkEndCommandBuffer(cb); + int submitted = submit_and_wait(st, cb); + dt->vkFreeCommandBuffers(st->dev, st->pool, 1, &cb); + if (!submitted) { + VKB_INFO(" %s, type %u: GPU submission failed", vkb_mem_strategy_name(s), type); + goto out; + } + if (!coherent) dt->vkInvalidateMappedMemoryRanges(st->dev, 1, &whole); + for (uint32_t i = 0; i < TEST_SIZE / 32; i++) { + if (((volatile uint32_t *)cmap)[i] != 0xA5A5A5A5u) { + VKB_INFO(" %s, type %u: the client does not see a GPU write (word %u = 0x%08x)", vkb_mem_strategy_name(s), type, i, + ((volatile uint32_t *)cmap)[i]); + goto out; + } + } + for (uint32_t i = 0; i < TEST_SIZE / 32; i++) { + uint32_t want = 0x5a000000u ^ ((TEST_SIZE / 8 + i) * 2654435761u); + uint32_t got = ((volatile uint32_t *)cmap)[TEST_SIZE / 16 * 3 + i]; + if (got != want) { + VKB_INFO(" %s, type %u: the GPU does not see a client write (word %u = 0x%08x, want 0x%08x)", vkb_mem_strategy_name(s), + type, i, got, want); + goto out; + } + } + result = coherent ? 1 : 2; + VKB_INFO(" %s, type %u (flags 0x%x): shared OK%s", vkb_mem_strategy_name(s), type, st->mp.memoryTypes[type].propertyFlags, + coherent ? ", coherent" : ", needs flushes"); +out: + if (cmap) munmap(cmap, (size_t)m->size); + if (smap) dt->vkUnmapMemory(st->dev, m->mem); + dt->vkDestroyBuffer(st->dev, buf, NULL); + dt->vkFreeMemory(st->dev, m->mem, NULL); + mem_release_backing(m); + return result; +} + +static int has_ext(const VkExtensionProperties *e, uint32_t n, const char *name) +{ + for (uint32_t i = 0; i < n; i++) + if (!strcmp(e[i].extensionName, name)) return 1; + return 0; +} + +void vkb_mem_selftest(vkb_pd_knowledge *k, VkInstance inst, const vkb_dispatch *idt, VkPhysicalDevice pd) +{ + selftest st; + memset(&st, 0, sizeof(st)); + st.idt = idt; + st.pd = pd; + idt->vkGetPhysicalDeviceMemoryProperties(pd, &st.mp); + + uint32_t nq = 0; + idt->vkGetPhysicalDeviceQueueFamilyProperties(pd, &nq, NULL); + VkQueueFamilyProperties qp[16]; + if (nq > 16) nq = 16; + idt->vkGetPhysicalDeviceQueueFamilyProperties(pd, &nq, qp); + st.qf = 0; + for (uint32_t i = 0; i < nq; i++) + if (qp[i].queueFlags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT)) { + st.qf = i; + break; + } + + uint32_t ne = 0; + idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &ne, NULL); + VkExtensionProperties *ex = calloc(ne ? ne : 1, sizeof(*ex)); + idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &ne, ex); + + uint32_t candidates[3]; + int nc = 0; + const char *force = getenv("VKBRIDGE_MEMORY"); + uint32_t order[] = {VKB_MEM_HOSTPTR, VKB_MEM_DMABUF, VKB_MEM_AHB}; + for (int i = 0; i < 3; i++) { + uint32_t s = order[i]; + if (force && strcmp(force, vkb_mem_strategy_name(s))) continue; + uint32_t n; + const char *const *req = vkb_mem_required_extensions(s, &n); + if (!req) continue; + int ok = 1; + for (uint32_t j = 0; j < n; j++) + if (strcmp(req[j], "VK_KHR_external_memory") && strcmp(req[j], "VK_KHR_sampler_ycbcr_conversion") && + strcmp(req[j], "VK_KHR_dedicated_allocation") && strcmp(req[j], "VK_KHR_get_memory_requirements2") && + !has_ext(ex, ne, req[j])) + ok = 0; + if (ok) candidates[nc++] = s; + else VKB_INFO("memory sharing: %s unavailable (driver lacks its extensions)", vkb_mem_strategy_name(s)); + } + + /* One test device with every candidate's extensions. */ + const char *exts[16]; + uint32_t nx = 0; + for (int i = 0; i < nc; i++) { + uint32_t n; + const char *const *req = vkb_mem_required_extensions(candidates[i], &n); + for (uint32_t j = 0; j < n; j++) { + if (!has_ext(ex, ne, req[j])) continue; + int dup = 0; + for (uint32_t q = 0; q < nx; q++) dup |= !strcmp(exts[q], req[j]); + if (!dup && nx < 16) exts[nx++] = req[j]; + } + } + free(ex); + float prio = 1.0f; + VkDeviceQueueCreateInfo qci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, NULL, 0, st.qf, 1, &prio}; + VkDeviceCreateInfo dci = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, NULL, 0, 1, &qci, 0, NULL, nx, exts, NULL}; + if (idt->vkCreateDevice(pd, &dci, NULL, &st.dev) != VK_SUCCESS) { + VKB_ERR("memory self-test: cannot create a device"); + return; + } + st.dt = *idt; + PFN_vkGetDeviceProcAddr gdpa = (PFN_vkGetDeviceProcAddr)vkb_gipa(inst, "vkGetDeviceProcAddr"); + vkb_dispatch_load_device(&st.dt, gdpa, st.dev); + st.dt.vkGetDeviceQueue(st.dev, st.qf, 0, &st.queue); + VkCommandPoolCreateInfo pci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, NULL, 0, st.qf}; + st.dt.vkCreateCommandPool(st.dev, &pci, NULL, &st.pool); + + VkPhysicalDeviceExternalMemoryHostPropertiesEXT hostp = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT}; + VkPhysicalDeviceProperties2 p2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, &hostp}; + idt->vkGetPhysicalDeviceProperties2(pd, &p2); + st.import_align = hostp.minImportedHostPointerAlignment ? hostp.minImportedHostPointerAlignment : 4096; + if (st.import_align < 4096) st.import_align = 4096; + + k->info.strategy = VKB_MEM_NONE; + for (int i = 0; i < nc; i++) { + uint32_t s = candidates[i]; + uint32_t shareable = 0, coherent = 0; + for (uint32_t t = 0; t < st.mp.memoryTypeCount; t++) { + if (!(st.mp.memoryTypes[t].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) continue; + if (st.mp.memoryTypes[t].propertyFlags & VK_MEMORY_PROPERTY_PROTECTED_BIT) continue; + int res = test_type(&st, s, t); + if (res) shareable |= 1u << t; + if (res == 1) coherent |= 1u << t; + } + if (coherent) { + k->info.strategy = s; + k->info.buffer_handle_types = strategy_handle_type(s); + k->info.shareable_types = shareable; + k->info.coherent_types = coherent; + k->info.import_alignment = st.import_align; + break; + } + VKB_INFO("memory sharing: %s failed the self-test", vkb_mem_strategy_name(s)); + } + if (k->info.strategy == VKB_MEM_NONE) + VKB_ERR("memory sharing: no method works on %s; Linux programs will get no host-visible memory", k->name); + + st.dt.vkDestroyCommandPool(st.dev, st.pool, NULL); + st.dt.vkDestroyDevice(st.dev, NULL); +} diff --git a/app/src/main/cpp/vkbridge/server_misc.c b/app/src/main/cpp/vkbridge/server_misc.c new file mode 100644 index 000000000..d05303621 --- /dev/null +++ b/app/src/main/cpp/vkbridge/server_misc.c @@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Descriptor update templates. The client repacks the app's data to the layout of the template + * it created on the server (entries rewritten to packed offsets), so the blob is used as is. + */ +#define _GNU_SOURCE +#include "vkb_server.h" + +#include + +void vkb_sv_vkbDescUpdateRaw(vkb_srv_call *c) +{ + VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d); + VkDescriptorSet set; + VkDescriptorUpdateTemplate tmpl; + vkb_dec_bytes(&c->d, &set, sizeof(set)); + vkb_dec_bytes(&c->d, &tmpl, sizeof(tmpl)); + size_t n = 0; + const void *data = vkb_dec_blob(&c->d, &n); + if (c->d.err || !c->table) { + vkb_srv_bad_message(c); + return; + } + if (!c->dt->vkUpdateDescriptorSetWithTemplate) { + vkb_srv_missing(c, "vkUpdateDescriptorSetWithTemplate"); + return; + } + c->dt->vkUpdateDescriptorSetWithTemplate(dev, set, tmpl, data); +} + +void vkb_sv_vkbPushDescRaw(vkb_srv_call *c) +{ + VkCommandBuffer cb = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(&c->d); + VkDescriptorUpdateTemplate tmpl; + VkPipelineLayout layout; + vkb_dec_bytes(&c->d, &tmpl, sizeof(tmpl)); + vkb_dec_bytes(&c->d, &layout, sizeof(layout)); + uint32_t set = vkb_dec_u32(&c->d); + size_t n = 0; + const void *data = vkb_dec_blob(&c->d, &n); + if (c->d.err || !c->table) { + vkb_srv_bad_message(c); + return; + } + if (!c->dt->vkCmdPushDescriptorSetWithTemplateKHR) { + vkb_srv_missing(c, "vkCmdPushDescriptorSetWithTemplateKHR"); + return; + } + c->dt->vkCmdPushDescriptorSetWithTemplateKHR(cb, tmpl, layout, set, data); +} diff --git a/app/src/main/cpp/vkbridge/vkb_server.h b/app/src/main/cpp/vkbridge/vkb_server.h new file mode 100644 index 000000000..67541968b --- /dev/null +++ b/app/src/main/cpp/vkbridge/vkb_server.h @@ -0,0 +1,116 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * DroidDeck Vulkan bridge - server side (bionic on the device, glibc for host tests). + * + * The server owns the real Vulkan objects. Linux programs in the session talk to it through the + * client ICD (tools/vkbridge/client) over a Unix socket; every connection is one client thread. + */ +#ifndef VKB_SERVER_H +#define VKB_SERVER_H + +#include +#include + +#include "vkb_server_iface.h" +#include "vkb_proto.h" +#include "vkb_log.h" +#include "gen/vkb_server_gen.h" + +#define VKB_MAX_TABLES 65536 +#define VKB_MAX_PDS 16 + +/* A client process (all connections that said hello with the same token). */ +typedef struct vkb_srv_proc { + uint64_t token; + int pid; + int conns; + struct vkb_srv_proc *next; +} vkb_srv_proc; + +typedef struct vkb_srv_conn { + int sock; + vkb_srv_proc *proc; + uint8_t *inbuf; + size_t incap; + vkb_arena arena; + pthread_t thread; +} vkb_srv_conn; + +/* Startup knowledge about each physical device (keyed by deviceUUID). */ +typedef struct vkb_pd_knowledge { + uint8_t uuid[VK_UUID_SIZE]; + char name[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + vkb_server_pd_info info; + int valid; +} vkb_pd_knowledge; + +/* A tracked device memory allocation. */ +typedef struct vkb_srv_mem { + VkDeviceMemory mem; + VkDeviceSize size; + uint32_t type; + uint32_t strategy; + void *host_ptr; /* hostptr: server's mapping of the client's memfd */ + size_t host_len; + void *mapped; /* server-side vkMapMemory pointer (for flush/invalidate) */ + void *ahb; /* AHardwareBuffer* (Android) */ + struct vkb_srv_mem *next; +} vkb_srv_mem; + +struct vkb_emu_device; + +typedef struct vkb_srv_table { + uint32_t id; + int is_device; + vkb_srv_proc *proc; + VkInstance instance; + VkDevice device; + VkPhysicalDevice physical; /* device tables */ + struct vkb_srv_table *parent; /* device -> instance */ + vkb_dispatch dt; /* what handlers call (may hold emulation wrappers) */ + vkb_dispatch real; /* the driver's own entry points */ + uint32_t api_version; + const vkb_pd_knowledge *pd; + pthread_mutex_t lock; + vkb_srv_mem *mems[256]; /* hash by handle */ + struct vkb_emu_device *emu; +} vkb_srv_table; + +/* server_main.c */ +extern PFN_vkGetInstanceProcAddr vkb_gipa; +extern vkb_dispatch vkb_global_dt; +extern int vkb_verbose; + +/* server_conn.c */ +void vkb_srv_serve(int listen_fd); +vkb_srv_table *vkb_table_get(uint32_t id); +uint32_t vkb_table_register(vkb_srv_table *t); +void vkb_table_unregister(vkb_srv_table *t); +void vkb_srv_reply_status(vkb_srv_call *c, uint32_t status); +/* The table of the call being executed on this thread (emulation wrappers use it). */ +vkb_srv_table *vkb_srv_current_table(void); +void vkb_srv_set_current_table(vkb_srv_table *t); +void vkb_proc_cleanup(vkb_srv_proc *p); + +/* server_instance.c */ +void vkb_selftest_all(void); +const vkb_pd_knowledge *vkb_pd_lookup(const vkb_dispatch *dt, VkPhysicalDevice pd); +extern vkb_pd_knowledge vkb_pds[VKB_MAX_PDS]; +extern int vkb_npds; + +/* server_memory.c */ +void vkb_mem_selftest(vkb_pd_knowledge *k, VkInstance inst, const vkb_dispatch *idt, VkPhysicalDevice pd); +const char *const *vkb_mem_required_extensions(uint32_t strategy, uint32_t *count); +void vkb_mem_track(vkb_srv_table *dev, vkb_srv_mem *m); +vkb_srv_mem *vkb_mem_find(vkb_srv_table *dev, VkDeviceMemory mem, int remove); +void vkb_mem_release(vkb_srv_table *dev, vkb_srv_mem *m); +void vkb_mem_free_all(vkb_srv_table *dev); + +/* emulation (server_emu*.c) */ +uint32_t vkb_emu_detect(const vkb_dispatch *idt, VkPhysicalDevice pd); +void vkb_emu_device_create_info(vkb_srv_table *inst, VkPhysicalDevice pd, uint32_t emu, + VkDeviceCreateInfo *ci, vkb_arena *a); +void vkb_emu_device_init(vkb_srv_table *dev, uint32_t emu); +void vkb_emu_device_destroy(vkb_srv_table *dev); + +#endif diff --git a/tools/vkbridge/client/cmdbuf.c b/tools/vkbridge/client/cmdbuf.c new file mode 100644 index 000000000..349b89703 --- /dev/null +++ b/tools/vkbridge/client/cmdbuf.c @@ -0,0 +1,231 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Command buffers: vkCmd* calls are encoded into the command buffer's own stream (no round trip + * each); vkEndCommandBuffer sends the stream in one message and the server replays it. + * + * Stream entry: u32 command id, u32 payload bytes, payload (8-aligned), padded to 8. + */ +#define _GNU_SOURCE +#include "vkb_client.h" +#include "gen/vkb_client_gen.h" + +#include + +static __thread vkb_cmdbuf *tls_encoding; + +int vkb_cb_begin_is_secondary(const VkCommandBufferBeginInfo *s) +{ + (void)s; + return tls_encoding && tls_encoding->level == VK_COMMAND_BUFFER_LEVEL_SECONDARY; +} + +vkb_enc *vkb_cmd_record_begin(VkCommandBuffer commandBuffer, uint32_t cmd) +{ + vkb_cmdbuf *cb = vkb_cb(commandBuffer); + if (!cb->recording) { + VKB_ONCE(VKB_LOG_WARN, "%s on a command buffer that is not recording (ignored; logged once)", vkb_cmd_names[cmd]); + return NULL; + } + vkb_enc *e = &cb->stream; + /* entries start 8-aligned */ + while (e->len & 7) vkb_enc_u8(e, 0); + vkb_enc_u32(e, cmd); + vkb_enc_u32(e, 0); + cb->entry = e->len; + return e; +} + +void vkb_cmd_record_end(VkCommandBuffer commandBuffer) +{ + vkb_cmdbuf *cb = vkb_cb(commandBuffer); + vkb_enc *e = &cb->stream; + if (e->oom) { + cb->broken = 1; + return; + } + if (e->nfds) { + VKB_ERR("internal: a recorded command carries a file descriptor"); + cb->broken = 1; + e->nfds = 0; + } + uint32_t n = (uint32_t)(e->len - cb->entry); + memcpy(e->buf + cb->entry - 4, &n, 4); +} + +static void stream_reset(vkb_cmdbuf *cb) +{ + if (cb->stream.cap > (8u << 20)) { + vkb_enc_free(&cb->stream); + vkb_enc_init(&cb->stream); + } else { + vkb_enc_reset(&cb->stream); + } + cb->recording = 0; + cb->broken = 0; +} + +/* ------------------------------------------------------------------ pools */ + +static vkb_cmdpool *pool_get(vkb_device *dev, VkCommandPool pool, int create) +{ + vkb_cmdpool *p = vkb_map_get(&dev->pools, (uint64_t)pool); + if (!p && create) { + p = calloc(1, sizeof(*p)); + vkb_map_put(&dev->pools, (uint64_t)pool, p); + } + return p; +} + +static void cmdbuf_free(vkb_cmdbuf *cb) +{ + vkb_enc_free(&cb->stream); + free(cb); +} + +void vkb_cmdpool_free(vkb_cmdpool *p) +{ + vkb_cmdbuf *cb = p->head; + while (cb) { + vkb_cmdbuf *n = cb->pool_next; + cmdbuf_free(cb); + cb = n; + } + free(p); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, + VkCommandBuffer *pCommandBuffers) +{ + VkResult r = vkb_wire_vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); + if (r != VK_SUCCESS) { + for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) pCommandBuffers[i] = VK_NULL_HANDLE; + return r; + } + vkb_device *dev = vkb_dev(device); + pthread_mutex_lock(&dev->lock); + vkb_cmdpool *p = pool_get(dev, pAllocateInfo->commandPool, 1); + for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) { + vkb_cmdbuf *cb = vkb_cb(pCommandBuffers[i]); + if (!cb) continue; + cb->pool = pAllocateInfo->commandPool; + cb->level = pAllocateInfo->level; + cb->pool_next = p->head; + cb->pool_prev = NULL; + if (p->head) p->head->pool_prev = cb; + p->head = cb; + } + pthread_mutex_unlock(&dev->lock); + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, + const VkCommandBuffer *pCommandBuffers) +{ + vkb_wire_vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); + vkb_device *dev = vkb_dev(device); + pthread_mutex_lock(&dev->lock); + vkb_cmdpool *p = pool_get(dev, commandPool, 0); + for (uint32_t i = 0; i < commandBufferCount; i++) { + vkb_cmdbuf *cb = vkb_cb(pCommandBuffers[i]); + if (!cb) continue; + if (p) { + if (cb->pool_prev) cb->pool_prev->pool_next = cb->pool_next; + else if (p->head == cb) p->head = cb->pool_next; + if (cb->pool_next) cb->pool_next->pool_prev = cb->pool_prev; + } + cmdbuf_free(cb); + } + pthread_mutex_unlock(&dev->lock); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) +{ + if (!commandPool) return; + vkb_wire_vkDestroyCommandPool(device, commandPool, pAllocator); + vkb_device *dev = vkb_dev(device); + pthread_mutex_lock(&dev->lock); + vkb_cmdpool *p = vkb_map_remove(&dev->pools, (uint64_t)commandPool); + pthread_mutex_unlock(&dev->lock); + if (p) vkb_cmdpool_free(p); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) +{ + VkResult r = vkb_wire_vkResetCommandPool(device, commandPool, flags); + vkb_device *dev = vkb_dev(device); + pthread_mutex_lock(&dev->lock); + vkb_cmdpool *p = pool_get(dev, commandPool, 0); + for (vkb_cmdbuf *cb = p ? p->head : NULL; cb; cb = cb->pool_next) stream_reset(cb); + pthread_mutex_unlock(&dev->lock); + return r; +} + +/* ------------------------------------------------------------------ recording */ + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) +{ + vkb_cmdbuf *cb = vkb_cb(commandBuffer); + stream_reset(cb); + cb->recording = 1; + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkBeginCommandBuffer); + vkb_enc_u64(e, cb->obj.remote); + tls_encoding = cb; + vkb_enc_u8(e, pBeginInfo != NULL); + if (pBeginInfo) vkb_enc_VkCommandBufferBeginInfo(e, pBeginInfo); + tls_encoding = NULL; + vkb_cmd_record_end(commandBuffer); + return cb->broken ? VK_ERROR_OUT_OF_HOST_MEMORY : VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEndCommandBuffer(VkCommandBuffer commandBuffer) +{ + vkb_cmdbuf *cb = vkb_cb(commandBuffer); + if (!cb->recording) return VK_SUCCESS; + cb->recording = 0; + if (cb->broken || cb->stream.oom) { + VKB_ERR("command buffer could not be recorded (out of memory)"); + stream_reset(cb); + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + vkb_call c; + vkb_call_begin(&c, VKB_CMD_vkEndCommandBuffer, cb->obj.table); + vkb_enc_u64(&c.e, cb->obj.remote); + vkb_enc_blob(&c.e, cb->stream.buf ? cb->stream.buf : (const void *)"", cb->stream.len); + VkResult r = VK_ERROR_DEVICE_LOST; + if (vkb_call_exec(&c)) { + r = (VkResult)vkb_dec_u32(&c.d); + vkb_call_end(&c); + } + stream_reset(cb); + return r; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) +{ + stream_reset(vkb_cb(commandBuffer)); + return vkb_wire_vkResetCommandBuffer(commandBuffer, flags); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, + const VkCommandBuffer *pCommandBuffers) +{ + vkb_wire_vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); +} + +/* Debug labels never reach the driver. */ +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) +{ + (void)commandBuffer; + (void)pLabelInfo; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) +{ + (void)commandBuffer; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) +{ + (void)commandBuffer; + (void)pLabelInfo; +} diff --git a/tools/vkbridge/client/compat/X11/Xlib.h b/tools/vkbridge/client/compat/X11/Xlib.h new file mode 100644 index 000000000..f6d4f1c85 --- /dev/null +++ b/tools/vkbridge/client/compat/X11/Xlib.h @@ -0,0 +1,10 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Minimal Xlib declarations for the bridge ICD: it never links libX11, it only needs the types + * vulkan_xlib.h names and looks up XGetXCBConnection at run time. */ +#ifndef VKB_COMPAT_XLIB_H +#define VKB_COMPAT_XLIB_H +typedef struct _XDisplay Display; +typedef unsigned long XID; +typedef XID Window; +typedef unsigned long VisualID; +#endif diff --git a/tools/vkbridge/client/compat/xcb/xcb.h b/tools/vkbridge/client/compat/xcb/xcb.h new file mode 100644 index 000000000..b21e9f3d5 --- /dev/null +++ b/tools/vkbridge/client/compat/xcb/xcb.h @@ -0,0 +1,37 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * Minimal xcb declarations for the bridge ICD: libxcb is opened at run time (dlopen), so only the + * types and the few request/reply layouts the software present path uses are declared here. */ +#ifndef VKB_COMPAT_XCB_H +#define VKB_COMPAT_XCB_H +#include +typedef struct xcb_connection_t xcb_connection_t; +typedef uint32_t xcb_window_t; +typedef uint32_t xcb_visualid_t; +typedef uint32_t xcb_drawable_t; +typedef uint32_t xcb_gcontext_t; +typedef uint32_t xcb_pixmap_t; +typedef struct { unsigned int sequence; } xcb_void_cookie_t; +typedef struct { unsigned int sequence; } xcb_get_geometry_cookie_t; +typedef struct { + uint8_t response_type; + uint8_t depth; + uint16_t sequence; + uint32_t length; + xcb_window_t root; + int16_t x, y; + uint16_t width, height, border_width; + uint8_t pad0[2]; +} xcb_get_geometry_reply_t; +typedef struct { + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; + uint32_t resource_id; + uint16_t minor_code; + uint8_t major_code; + uint8_t pad0; + uint32_t pad[5]; + uint32_t full_sequence; +} xcb_generic_error_t; +#define XCB_IMAGE_FORMAT_Z_PIXMAP 2 +#endif diff --git a/tools/vkbridge/client/conn.c b/tools/vkbridge/client/conn.c new file mode 100644 index 000000000..841fe5366 --- /dev/null +++ b/tools/vkbridge/client/conn.c @@ -0,0 +1,449 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Client transport: one Unix-socket connection per thread (the server mirrors it with one thread), + * so calls from different threads run in parallel exactly as they would on a local driver. + */ +#define _GNU_SOURCE +#include "vkb_client.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* ------------------------------------------------------------------ logging */ + +static int log_level_v = -1; +static FILE *log_file; +static pthread_mutex_t log_lock = PTHREAD_MUTEX_INITIALIZER; + +int vkb_log_level(void) +{ + if (log_level_v < 0) { + const char *d = getenv("VKBRIDGE_DEBUG"); + log_level_v = d && *d && strcmp(d, "0") ? VKB_LOG_DEBUG : VKB_LOG_WARN; + const char *v = getenv("VKBRIDGE_LOG_LEVEL"); + if (v) log_level_v = atoi(v); + const char *f = getenv("VKBRIDGE_CLIENT_LOG"); + if (f && *f) log_file = fopen(f, "ae"); + } + return log_level_v; +} + +void vkb_log(int level, const char *fmt, ...) +{ + if (level > vkb_log_level()) return; + char msg[2048]; + va_list ap; + va_start(ap, fmt); + vsnprintf(msg, sizeof(msg), fmt, ap); + va_end(ap); + static const char *const tags[] = {"error", "warning", "info", "debug"}; + char comm[32] = "?"; + FILE *cf = fopen("/proc/self/comm", "re"); + if (cf) { + if (fgets(comm, sizeof(comm), cf)) comm[strcspn(comm, "\n")] = 0; + fclose(cf); + } + pthread_mutex_lock(&log_lock); + fprintf(stderr, "vkbridge %s [%s %d]: %s\n", tags[level & 3], comm, getpid(), msg); + if (log_file) { + struct timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + struct tm tm; + localtime_r(&ts.tv_sec, &tm); + fprintf(log_file, "%02d:%02d:%02d.%03ld vkbridge-client %s [%s %d]: %s\n", tm.tm_hour, tm.tm_min, tm.tm_sec, + ts.tv_nsec / 1000000, tags[level & 3], comm, getpid(), msg); + fflush(log_file); + } + pthread_mutex_unlock(&log_lock); +} + +/* ------------------------------------------------------------------ connection */ + +typedef struct vkb_conn { + int sock; + int dead; + uint32_t epoch; + vkb_enc enc; /* reused request buffer */ + uint8_t *in; + size_t incap; + vkb_arena arena; + int busy; +} vkb_conn; + +static uint64_t process_token; +static uint32_t fork_epoch; +static pthread_key_t conn_key; +static pthread_once_t conn_once = PTHREAD_ONCE_INIT; +static __thread vkb_conn *tls_conn; + +static void conn_free(vkb_conn *c) +{ + if (!c) return; + if (c->sock >= 0) close(c->sock); + vkb_enc_free(&c->enc); + free(c->in); + vkb_arena_free(&c->arena); + free(c); +} + +static void conn_thread_exit(void *p) +{ + conn_free(p); +} + +static void atfork_child(void) +{ + /* The child must not talk on the parent's sockets: new token, new connections. */ + fork_epoch++; + process_token = 0; + tls_conn = NULL; /* the old one is leaked deliberately: its socket belongs to the parent too */ +} + +static void conn_init_once(void) +{ + pthread_key_create(&conn_key, conn_thread_exit); + pthread_atfork(NULL, NULL, atfork_child); +} + +void vkb_conn_after_fork(void) { atfork_child(); } + +static uint64_t make_token(void) +{ + uint64_t t = 0; + int fd = open("/dev/urandom", O_RDONLY | O_CLOEXEC); + if (fd >= 0) { + if (read(fd, &t, sizeof(t)) != sizeof(t)) t = 0; + close(fd); + } + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + t ^= ((uint64_t)getpid() << 32) ^ (uint64_t)ts.tv_nsec ^ (uint64_t)ts.tv_sec * 1000003u; + return t ? t : 1; +} + +static const char *socket_path(void) +{ + const char *p = getenv(VKB_DEFAULT_SOCKET_ENV); + if (p && *p) return p; + static char buf[256]; + const char *rd = getenv("XDG_RUNTIME_DIR"); + snprintf(buf, sizeof(buf), "%s/vkbridge.sock", rd && *rd ? rd : "/tmp"); + return buf; +} + +static int do_connect(vkb_conn *c) +{ + const char *path = socket_path(); + struct sockaddr_un a; + memset(&a, 0, sizeof(a)); + a.sun_family = AF_UNIX; + if (strlen(path) >= sizeof(a.sun_path)) { + VKB_ERR("socket path too long: %s", path); + return -1; + } + strcpy(a.sun_path, path); + int s = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0); + if (s < 0) return -1; + if (connect(s, (struct sockaddr *)&a, sizeof(a)) < 0) { + VKB_ONCE(VKB_LOG_ERROR, "cannot reach the Vulkan bridge server at %s: %s", path, strerror(errno)); + close(s); + return -1; + } + c->sock = s; + /* Hello: protocol check and which process this thread belongs to. */ + if (!process_token) process_token = make_token(); + vkb_enc e; + vkb_enc_init(&e); + vkb_enc_u64(&e, VKB_PROTOCOL_HASH); + vkb_enc_u64(&e, process_token); + vkb_enc_u32(&e, (uint32_t)getpid()); + char comm[64] = "?"; + FILE *f = fopen("/proc/self/comm", "re"); + if (f) { + if (fgets(comm, sizeof(comm), f)) comm[strcspn(comm, "\n")] = 0; + fclose(f); + } + vkb_enc_str(&e, comm); + vkb_msg_hdr h = {VKB_MAGIC, (uint32_t)e.len, VKB_CMD_vkbHello, 0, 0, 0}; + int ok = vkb_send_msg(s, &h, e.buf, NULL, 0) == 0; + vkb_enc_free(&e); + int fds[VKB_MAX_FDS], nfds = 0; + vkb_msg_hdr rh; + if (ok) ok = vkb_recv_msg(s, &rh, &c->in, &c->incap, fds, &nfds) == 0 && rh.cmd == VKB_ST_OK && rh.size >= 12; + if (ok) { + uint64_t sh; + uint32_t accepted; + memcpy(&sh, c->in, 8); + memcpy(&accepted, c->in + 8, 4); + if (!accepted) { + VKB_ONCE(VKB_LOG_ERROR, "the bridge server speaks protocol %016llx, this driver %016llx; update DroidDeck's Linux side", + (unsigned long long)sh, (unsigned long long)VKB_PROTOCOL_HASH); + ok = 0; + } + } + if (!ok) { + close(s); + c->sock = -1; + return -1; + } + return 0; +} + +static vkb_conn *get_conn(void) +{ + pthread_once(&conn_once, conn_init_once); + vkb_conn *c = tls_conn; + if (c && c->epoch != fork_epoch) c = tls_conn = NULL; + if (c) return c->dead ? NULL : c; + c = calloc(1, sizeof(*c)); + if (!c) return NULL; + c->sock = -1; + c->epoch = fork_epoch; + vkb_enc_init(&c->enc); + if (do_connect(c) < 0) { + c->dead = 1; + } + tls_conn = c; + pthread_setspecific(conn_key, c); + return c->dead ? NULL : c; +} + +int vkb_connected(void) +{ + return get_conn() != NULL; +} + +void vkb_call_begin(vkb_call *c, uint32_t cmd, uint32_t table) +{ + memset(c, 0, sizeof(*c)); + c->cmd = cmd; + c->table = table; + c->conn = get_conn(); + if (c->conn && !c->conn->busy) { + c->conn->busy = 1; + c->e = c->conn->enc; + vkb_enc_reset(&c->e); + } else { + /* No connection, or a nested call: encode into a private buffer. */ + if (c->conn && c->conn->busy) VKB_ERR("internal: nested bridge call (%s)", vkb_cmd_names[cmd]); + vkb_enc_init(&c->e); + c->flags |= 0x80000000u; + } +} + +static void release_enc(vkb_call *c) +{ + if (c->flags & 0x80000000u) { + vkb_enc_free(&c->e); + } else if (c->conn) { + c->conn->enc = c->e; + c->conn->busy = 0; + /* Don't keep a huge buffer around after one big message. */ + if (c->conn->enc.cap > (16u << 20)) { + vkb_enc_free(&c->conn->enc); + vkb_enc_init(&c->conn->enc); + } + } +} + +int vkb_call_exec(vkb_call *c) +{ + vkb_conn *conn = c->conn; + if (!conn || conn->dead || (c->flags & 0x80000000u)) { + release_enc(c); + c->conn = NULL; + return 0; + } + if (c->e.oom) { + VKB_ERR("%s: request could not be encoded", vkb_cmd_names[c->cmd]); + release_enc(c); + c->conn = NULL; + return 0; + } + vkb_msg_hdr h = {VKB_MAGIC, (uint32_t)c->e.len, c->cmd, c->table, (uint32_t)c->e.nfds, c->flags & VKB_F_NOREPLY}; + if (vkb_send_msg(conn->sock, &h, c->e.buf, c->e.fds, c->e.nfds) < 0) { + VKB_ERR("%s: lost the bridge server (%s)", vkb_cmd_names[c->cmd], strerror(errno)); + conn->dead = 1; + release_enc(c); + c->conn = NULL; + return 0; + } + release_enc(c); + if (c->flags & VKB_F_NOREPLY) { + c->conn = NULL; + return 1; + } + int fds[VKB_MAX_FDS], nfds = 0; + vkb_msg_hdr rh; + if (vkb_recv_msg(conn->sock, &rh, &conn->in, &conn->incap, fds, &nfds) < 0) { + VKB_ERR("%s: lost the bridge server while waiting for the reply", vkb_cmd_names[c->cmd]); + conn->dead = 1; + c->conn = NULL; + return 0; + } + if (rh.cmd != VKB_ST_OK) { + static const char *const why[] = {"ok", "malformed request", "the driver lacks this command", "unknown object"}; + VKB_ERR("%s: the server refused the call (%s)", vkb_cmd_names[c->cmd], rh.cmd < 4 ? why[rh.cmd] : "?"); + for (int i = 0; i < nfds; i++) close(fds[i]); + c->conn = NULL; + return 0; + } + /* The decoder keeps fds in a per-call array. */ + static __thread int call_fds[VKB_MAX_FDS]; + memcpy(call_fds, fds, sizeof(int) * (size_t)nfds); + vkb_dec_init(&c->d, conn->in, rh.size, &conn->arena, call_fds, nfds); + return 1; +} + +void vkb_call_end(vkb_call *c) +{ + if (!c->conn) return; + if (c->d.err) VKB_ERR("%s: malformed reply", vkb_cmd_names[c->cmd]); + vkb_dec_close_untaken(&c->d); + vkb_arena_reset(&c->conn->arena); + c->conn = NULL; +} + +uint32_t vkb_table_of(const void *h) +{ + return h ? ((const vkb_object *)h)->table : 0; +} + +uint64_t vkb_remote(const void *h) +{ + return h ? ((const vkb_object *)h)->remote : 0; +} + +int vkb_memfd(const char *name, size_t size) +{ + int fd = (int)syscall(SYS_memfd_create, name, 1u /* MFD_CLOEXEC */); + if (fd < 0) { + /* No memfd (old kernel or a filter): an unlinked file in the runtime dir. */ + char path[256]; + const char *rd = getenv("XDG_RUNTIME_DIR"); + snprintf(path, sizeof(path), "%s/vkbridge-XXXXXX", rd && *rd ? rd : "/tmp"); + fd = mkostemp(path, O_CLOEXEC); + if (fd < 0) return -1; + unlink(path); + } + if (ftruncate(fd, (off_t)size) < 0) { + close(fd); + return -1; + } + return fd; +} + +/* ------------------------------------------------------------------ hash map */ + +void vkb_map_init(vkb_map *m) +{ + memset(m, 0, sizeof(*m)); + pthread_mutex_init(&m->lock, NULL); +} + +void vkb_map_destroy(vkb_map *m) +{ + free(m->keys); + free(m->vals); + pthread_mutex_destroy(&m->lock); + memset(m, 0, sizeof(*m)); +} + +static uint32_t hash64(uint64_t k) +{ + k ^= k >> 33; + k *= 0xff51afd7ed558ccdull; + k ^= k >> 33; + return (uint32_t)k; +} + +/* Keys are never 0 (VK_NULL_HANDLE); 0 marks an empty slot, ~0 a deleted one. */ +#define TOMB (~(uint64_t)0) + +static void map_rehash(vkb_map *m, uint32_t ncap) +{ + uint64_t *ok = m->keys; + void **ov = m->vals; + uint32_t oc = m->cap; + m->keys = calloc(ncap, sizeof(uint64_t)); + m->vals = calloc(ncap, sizeof(void *)); + m->cap = ncap; + m->count = 0; + for (uint32_t i = 0; i < oc; i++) { + if (ok[i] && ok[i] != TOMB) { + uint32_t j = hash64(ok[i]) & (ncap - 1); + while (m->keys[j]) j = (j + 1) & (ncap - 1); + m->keys[j] = ok[i]; + m->vals[j] = ov[i]; + m->count++; + } + } + free(ok); + free(ov); +} + +void vkb_map_put(vkb_map *m, uint64_t k, void *v) +{ + if (!k) return; + pthread_mutex_lock(&m->lock); + if (!m->cap || (m->count + 1) * 2 > m->cap) map_rehash(m, m->cap ? m->cap * 2 : 64); + uint32_t j = hash64(k) & (m->cap - 1); + int64_t tomb = -1; + while (m->keys[j]) { + if (m->keys[j] == k) { + m->vals[j] = v; + pthread_mutex_unlock(&m->lock); + return; + } + if (m->keys[j] == TOMB && tomb < 0) tomb = j; + j = (j + 1) & (m->cap - 1); + } + if (tomb >= 0) j = (uint32_t)tomb; + m->keys[j] = k; + m->vals[j] = v; + m->count++; + pthread_mutex_unlock(&m->lock); +} + +static int64_t map_find(vkb_map *m, uint64_t k) +{ + if (!m->cap || !k) return -1; + uint32_t j = hash64(k) & (m->cap - 1); + for (uint32_t n = 0; n < m->cap && m->keys[j]; n++) { + if (m->keys[j] == k) return j; + j = (j + 1) & (m->cap - 1); + } + return -1; +} + +void *vkb_map_get(vkb_map *m, uint64_t k) +{ + pthread_mutex_lock(&m->lock); + int64_t j = map_find(m, k); + void *v = j >= 0 ? m->vals[j] : NULL; + pthread_mutex_unlock(&m->lock); + return v; +} + +void *vkb_map_remove(vkb_map *m, uint64_t k) +{ + pthread_mutex_lock(&m->lock); + int64_t j = map_find(m, k); + void *v = NULL; + if (j >= 0) { + v = m->vals[j]; + m->keys[j] = TOMB; + m->vals[j] = NULL; + /* count keeps tombstones, so the table rehashes before it fills with them */ + } + pthread_mutex_unlock(&m->lock); + return v; +} diff --git a/tools/vkbridge/client/descriptor.c b/tools/vkbridge/client/descriptor.c new file mode 100644 index 000000000..c06807168 --- /dev/null +++ b/tools/vkbridge/client/descriptor.c @@ -0,0 +1,270 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Descriptor update templates and private data. + * + * A template's data is laid out by the app (offsets and strides into its own structures). The + * server's copy of the template is created with packed entries instead, and every update packs + * the app's data the same way before sending it, so the server passes the blob straight on. + */ +#define _GNU_SOURCE +#include "vkb_client.h" +#include "gen/vkb_client_gen.h" + +#include + +typedef struct vkb_template { + uint32_t count; + size_t size; /* packed bytes */ + VkDescriptorUpdateTemplateEntry *app; /* the app's entries */ + size_t *packed; /* packed offset per entry */ + size_t *elem; /* element size per entry (inline: 1) */ +} vkb_template; + +static size_t elem_size(VkDescriptorType t) +{ + switch (t) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + return sizeof(VkDescriptorImageInfo); + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + return sizeof(VkDescriptorBufferInfo); + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + return sizeof(VkBufferView); + case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: + return 1; + default: + return 8; + } +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkDescriptorUpdateTemplate *pTemplate) +{ + uint32_t n = pCreateInfo->descriptorUpdateEntryCount; + vkb_template *t = calloc(1, sizeof(*t)); + t->count = n; + t->app = calloc(n ? n : 1, sizeof(*t->app)); + t->packed = calloc(n ? n : 1, sizeof(size_t)); + t->elem = calloc(n ? n : 1, sizeof(size_t)); + VkDescriptorUpdateTemplateEntry *packed = calloc(n ? n : 1, sizeof(*packed)); + size_t off = 0; + for (uint32_t i = 0; i < n; i++) { + const VkDescriptorUpdateTemplateEntry *e = &pCreateInfo->pDescriptorUpdateEntries[i]; + t->app[i] = *e; + size_t es = elem_size(e->descriptorType); + t->elem[i] = es; + t->packed[i] = off; + packed[i] = *e; + packed[i].offset = off; + packed[i].stride = es; + off += (es * e->descriptorCount + 7) & ~(size_t)7; + } + t->size = off; + VkDescriptorUpdateTemplateCreateInfo ci = *pCreateInfo; + ci.pDescriptorUpdateEntries = packed; + VkResult r = vkb_wire_vkCreateDescriptorUpdateTemplate(device, &ci, pAllocator, pTemplate); + free(packed); + if (r != VK_SUCCESS) { + free(t->app); + free(t->packed); + free(t->elem); + free(t); + return r; + } + vkb_map_put(&vkb_dev(device)->templates, (uint64_t)*pTemplate, t); + return r; +} + +static void template_free(vkb_template *t) +{ + if (!t) return; + free(t->app); + free(t->packed); + free(t->elem); + free(t); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate tmpl, + const VkAllocationCallbacks *pAllocator) +{ + if (!tmpl) return; + template_free(vkb_map_remove(&vkb_dev(device)->templates, (uint64_t)tmpl)); + vkb_wire_vkDestroyDescriptorUpdateTemplate(device, tmpl, pAllocator); +} + +static void pack(const vkb_template *t, const void *pData, uint8_t *out) +{ + const uint8_t *src = pData; + for (uint32_t i = 0; i < t->count; i++) { + const VkDescriptorUpdateTemplateEntry *e = &t->app[i]; + uint8_t *dst = out + t->packed[i]; + if (e->descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) { + memcpy(dst, src + e->offset, e->descriptorCount); + continue; + } + size_t es = t->elem[i]; + for (uint32_t j = 0; j < e->descriptorCount; j++) memcpy(dst + j * es, src + e->offset + (size_t)j * e->stride, es); + } +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet set, VkDescriptorUpdateTemplate tmpl, + const void *pData) +{ + vkb_device *dev = vkb_dev(device); + vkb_template *t = vkb_map_get(&dev->templates, (uint64_t)tmpl); + if (!t) { + VKB_ERR("vkUpdateDescriptorSetWithTemplate with an unknown template"); + return; + } + vkb_call c; + vkb_call_begin(&c, VKB_CMD_vkbDescUpdateRaw, dev->obj.table); + vkb_enc_u64(&c.e, dev->obj.remote); + vkb_enc_bytes(&c.e, &set, sizeof(set)); + vkb_enc_bytes(&c.e, &tmpl, sizeof(tmpl)); + /* Packed straight into the request. */ + vkb_enc_u8(&c.e, 1); + vkb_enc_u64(&c.e, t->size); + size_t at = vkb_enc_raw(&c.e, NULL, t->size); + if (!c.e.oom) pack(t, pData, c.e.buf + at); + if (vkb_call_exec(&c)) vkb_call_end(&c); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate tmpl, + VkPipelineLayout layout, uint32_t set, const void *pData) +{ + vkb_cmdbuf *cb = vkb_cb(commandBuffer); + vkb_template *t = vkb_map_get(&cb->device->templates, (uint64_t)tmpl); + if (!t) { + VKB_ERR("vkCmdPushDescriptorSetWithTemplateKHR with an unknown template"); + return; + } + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkbPushDescRaw); + if (!e) return; + vkb_enc_u64(e, cb->obj.remote); + vkb_enc_bytes(e, &tmpl, sizeof(tmpl)); + vkb_enc_bytes(e, &layout, sizeof(layout)); + vkb_enc_u32(e, set); + vkb_enc_u8(e, 1); + vkb_enc_u64(e, t->size); + size_t at = vkb_enc_raw(e, NULL, t->size); + if (!e->oom) pack(t, pData, e->buf + at); + vkb_cmd_record_end(commandBuffer); +} + +/* ------------------------------------------------------------------ private data (client-local) */ + +typedef struct vkb_private_slot { + vkb_map values; +} vkb_private_slot; + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pSlot) +{ + (void)device; + (void)pCreateInfo; + (void)pAllocator; + vkb_private_slot *s = calloc(1, sizeof(*s)); + if (!s) return VK_ERROR_OUT_OF_HOST_MEMORY; + vkb_map_init(&s->values); + *pSlot = (VkPrivateDataSlot)(uintptr_t)s; + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot slot, const VkAllocationCallbacks *pAllocator) +{ + (void)device; + (void)pAllocator; + vkb_private_slot *s = (vkb_private_slot *)(uintptr_t)slot; + if (!s) return; + vkb_map_destroy(&s->values); + free(s); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, + VkPrivateDataSlot slot, uint64_t data) +{ + (void)device; + (void)objectType; + vkb_private_slot *s = (vkb_private_slot *)(uintptr_t)slot; + vkb_map_put(&s->values, objectHandle, (void *)(uintptr_t)data); + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, + VkPrivateDataSlot slot, uint64_t *pData) +{ + (void)device; + (void)objectType; + vkb_private_slot *s = (vkb_private_slot *)(uintptr_t)slot; + *pData = (uint64_t)(uintptr_t)vkb_map_get(&s->values, objectHandle); +} + +/* ------------------------------------------------------------------ debug utils (no-ops) */ + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) +{ + (void)device; + (void)pNameInfo; + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) +{ + (void)device; + (void)pTagInfo; + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) +{ + (void)queue; + (void)pLabelInfo; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkQueueEndDebugUtilsLabelEXT(VkQueue queue) +{ + (void)queue; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) +{ + (void)queue; + (void)pLabelInfo; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger) +{ + (void)instance; + (void)pCreateInfo; + (void)pAllocator; + static uint64_t next = 1; + *pMessenger = (VkDebugUtilsMessengerEXT)(uintptr_t)__atomic_fetch_add(&next, 1, __ATOMIC_RELAXED); + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks *pAllocator) +{ + (void)instance; + (void)messenger; + (void)pAllocator; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT severity, + VkDebugUtilsMessageTypeFlagsEXT types, + const VkDebugUtilsMessengerCallbackDataEXT *pData) +{ + (void)instance; + (void)severity; + (void)types; + (void)pData; +} diff --git a/tools/vkbridge/client/emu.c b/tools/vkbridge/client/emu.c new file mode 100644 index 000000000..703af4371 --- /dev/null +++ b/tools/vkbridge/client/emu.c @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Client side of feature emulation (Phase 4 fills this in). + */ +#define _GNU_SOURCE +#include "emu.h" + +const VkExtensionProperties *vkb_emu_extensions(vkb_physdev *pd, uint32_t *n) +{ + (void)pd; + *n = 0; + return NULL; +} + +void vkb_emu_patch_limits(vkb_physdev *pd, VkPhysicalDeviceProperties *p) { (void)pd; (void)p; } +void vkb_emu_patch_properties_chain(vkb_physdev *pd, VkBaseOutStructure *b) { (void)pd; (void)b; } +void vkb_emu_patch_features(vkb_physdev *pd, VkPhysicalDeviceFeatures *f) { (void)pd; (void)f; } +void vkb_emu_patch_features_chain(vkb_physdev *pd, VkBaseOutStructure *b) { (void)pd; (void)b; } + +int vkb_emu_format_properties(vkb_physdev *pd, VkFormat format, VkFormatProperties *fp, VkFormatProperties2 *fp2) +{ + (void)pd; (void)format; (void)fp; (void)fp2; + return 0; +} + +VkFormat vkb_emu_real_format(vkb_physdev *pd, VkFormat format, VkImageUsageFlags *usage, VkImageCreateFlags *flags) +{ + (void)pd; (void)usage; (void)flags; + return format; +} + +int vkb_emu_is_emulated_format(vkb_physdev *pd, VkFormat format) { (void)pd; (void)format; return 0; } +void vkb_emu_image_create_info(vkb_device *dev, VkImageCreateInfo *ci) { (void)dev; (void)ci; } +void vkb_emu_image_created(vkb_device *dev, const VkImageCreateInfo *ci, VkImage image) { (void)dev; (void)ci; (void)image; } +void vkb_emu_image_destroyed(vkb_device *dev, VkImage image) { (void)dev; (void)image; } diff --git a/tools/vkbridge/client/emu.h b/tools/vkbridge/client/emu.h new file mode 100644 index 000000000..13b1a2ad9 --- /dev/null +++ b/tools/vkbridge/client/emu.h @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Client side of feature emulation: reporting what the server emulates (see server_emu.c). + */ +#ifndef VKB_CLIENT_EMU_H +#define VKB_CLIENT_EMU_H + +#include "vkb_client.h" + +const VkExtensionProperties *vkb_emu_extensions(vkb_physdev *pd, uint32_t *n); +void vkb_emu_patch_limits(vkb_physdev *pd, VkPhysicalDeviceProperties *p); +void vkb_emu_patch_properties_chain(vkb_physdev *pd, VkBaseOutStructure *b); +void vkb_emu_patch_features(vkb_physdev *pd, VkPhysicalDeviceFeatures *f); +void vkb_emu_patch_features_chain(vkb_physdev *pd, VkBaseOutStructure *b); +/* 1 = handled (format is emulated). fp2 may be NULL. */ +int vkb_emu_format_properties(vkb_physdev *pd, VkFormat format, VkFormatProperties *fp, VkFormatProperties2 *fp2); +/* The format the server really uses for an emulated one (usage/flags adjusted); else format. */ +VkFormat vkb_emu_real_format(vkb_physdev *pd, VkFormat format, VkImageUsageFlags *usage, VkImageCreateFlags *flags); +int vkb_emu_is_emulated_format(vkb_physdev *pd, VkFormat format); +void vkb_emu_image_create_info(vkb_device *dev, VkImageCreateInfo *ci); +void vkb_emu_image_created(vkb_device *dev, const VkImageCreateInfo *ci, VkImage image); +void vkb_emu_image_destroyed(vkb_device *dev, VkImage image); + +#endif diff --git a/tools/vkbridge/client/icd.c b/tools/vkbridge/client/icd.c new file mode 100644 index 000000000..08e1c7003 --- /dev/null +++ b/tools/vkbridge/client/icd.c @@ -0,0 +1,586 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Loader interface, instances, physical devices, devices and queues. + */ +#define _GNU_SOURCE +#include "vkb_client.h" +#include "gen/vkb_client_gen.h" +#include "wsi.h" + +#include +#include + +/* ------------------------------------------------------------------ proc lookup */ + +static int proc_cmp(const void *a, const void *b) +{ + return strcmp(((const vkb_proc_desc *)a)->name, ((const vkb_proc_desc *)b)->name); +} + +static vkb_proc_desc *sorted_procs; +static pthread_once_t procs_once = PTHREAD_ONCE_INIT; + +static void procs_init(void) +{ + sorted_procs = malloc(vkb_client_proc_count * sizeof(vkb_proc_desc)); + memcpy(sorted_procs, vkb_client_procs, vkb_client_proc_count * sizeof(vkb_proc_desc)); + qsort(sorted_procs, vkb_client_proc_count, sizeof(vkb_proc_desc), proc_cmp); +} + +static const vkb_proc_desc *find_proc(const char *name) +{ + pthread_once(&procs_once, procs_init); + vkb_proc_desc key = {name, NULL, 0, NULL}; + return bsearch(&key, sorted_procs, vkb_client_proc_count, sizeof(vkb_proc_desc), proc_cmp); +} + +int vkb_device_ext_enabled(const vkb_device *d, const char *name) +{ + for (uint32_t i = 0; i < d->enabled_ext_count; i++) + if (!strcmp(d->enabled_exts[i], name)) return 1; + return 0; +} + +PFN_vkVoidFunction vkb_lookup_proc(const char *name, int level_max, vkb_device *dev, vkb_instance *inst) +{ + (void)inst; + if (!name) return NULL; + const vkb_proc_desc *p = find_proc(name); + if (!p) return NULL; + 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; + } + return p->fn; +} + +/* ------------------------------------------------------------------ loader entry points */ + +VKB_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t *pVersion) +{ + if (*pVersion > 5) *pVersion = 5; + return VK_SUCCESS; +} + +VKB_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char *pName) +{ + if (!pName) return NULL; + if (!instance) { + const vkb_proc_desc *p = find_proc(pName); + if (!p) return NULL; + if (p->level == VKB_LEVEL_GLOBAL || !strcmp(pName, "vkGetInstanceProcAddr")) return p->fn; + return NULL; + } + return vkb_lookup_proc(pName, VKB_LEVEL_DEVICE + 1, NULL, vkb_inst(instance)); +} + +VKB_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance instance, const char *pName) +{ + const vkb_proc_desc *p = find_proc(pName); + if (!p || p->level != VKB_LEVEL_PHYSDEV) return NULL; + (void)instance; + return p->fn; +} + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkb_ep_vkGetInstanceProcAddr(VkInstance instance, const char *pName) +{ + return vk_icdGetInstanceProcAddr(instance, pName); +} + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkb_ep_vkGetDeviceProcAddr(VkDevice device, const char *pName) +{ + return vkb_lookup_proc(pName, VKB_LEVEL_DEVICE, vkb_dev(device), NULL); +} + +/* ------------------------------------------------------------------ wrapping server objects */ + +void *vkb_wrap(VkObjectType type, const void *parent, uint64_t remote) +{ + if (!remote) return NULL; + switch (type) { + case VK_OBJECT_TYPE_PHYSICAL_DEVICE: { + vkb_instance *inst = (vkb_instance *)parent; + pthread_mutex_lock(&inst->lock); + vkb_physdev *pd = inst->pds; + while (pd && pd->obj.remote != remote) pd = pd->list_next; + if (!pd) { + pd = calloc(1, sizeof(*pd)); + pd->obj.loader.loaderMagic = ICD_LOADER_MAGIC; + pd->obj.type = type; + pd->obj.remote = remote; + pd->obj.table = inst->obj.table; + pd->instance = inst; + pthread_mutex_init(&pd->lock, NULL); + pd->list_next = inst->pds; + inst->pds = pd; + } + pthread_mutex_unlock(&inst->lock); + return pd; + } + case VK_OBJECT_TYPE_QUEUE: { + vkb_device *dev = (vkb_device *)parent; + pthread_mutex_lock(&dev->lock); + vkb_queue *q = dev->queues; + while (q && q->obj.remote != remote) q = q->next; + if (!q) { + q = calloc(1, sizeof(*q)); + q->obj.loader.loaderMagic = ICD_LOADER_MAGIC; + q->obj.type = type; + q->obj.remote = remote; + q->obj.table = dev->obj.table; + q->device = dev; + q->next = dev->queues; + dev->queues = q; + } + pthread_mutex_unlock(&dev->lock); + return q; + } + case VK_OBJECT_TYPE_COMMAND_BUFFER: { + vkb_device *dev = (vkb_device *)parent; + vkb_cmdbuf *cb = calloc(1, sizeof(*cb)); + cb->obj.loader.loaderMagic = ICD_LOADER_MAGIC; + cb->obj.type = type; + cb->obj.remote = remote; + cb->obj.table = dev->obj.table; + cb->device = dev; + vkb_enc_init(&cb->stream); + return cb; + } + default: + VKB_ERR("internal: cannot wrap object type %d", type); + return NULL; + } +} + +/* ------------------------------------------------------------------ instance */ + +static uint32_t server_instance_version(void) +{ + static uint32_t v; + if (!v) { + uint32_t sv = VK_API_VERSION_1_0; + if (vkb_wire_vkEnumerateInstanceVersion(&sv) != VK_SUCCESS) return VK_API_VERSION_1_0; + v = sv < VKB_API_VERSION ? sv : VKB_API_VERSION; + } + return v; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateInstanceVersion(uint32_t *pApiVersion) +{ + if (!vkb_connected()) { + *pApiVersion = VK_API_VERSION_1_0; + return VK_SUCCESS; + } + *pApiVersion = server_instance_version(); + return VK_SUCCESS; +} + +static const char *const client_instance_exts[] = { + "VK_KHR_surface", "VK_KHR_wayland_surface", "VK_KHR_xcb_surface", "VK_KHR_xlib_surface", + "VK_EXT_headless_surface", "VK_KHR_get_surface_capabilities2", "VK_EXT_swapchain_colorspace", + "VK_EXT_debug_utils", +}; + +static int bridged_ext(const char *name, int device) +{ + for (int i = 0; i < VKB_EXT_COUNT; i++) + if (vkb_exts[i].device == device && !vkb_exts[i].client && !strcmp(vkb_exts[i].name, name)) return 1; + return 0; +} + +static VkResult fill_props(const VkExtensionProperties *list, uint32_t n, uint32_t *pCount, VkExtensionProperties *out) +{ + if (!out) { + *pCount = n; + return VK_SUCCESS; + } + uint32_t c = *pCount < n ? *pCount : n; + memcpy(out, list, c * sizeof(*out)); + *pCount = c; + return c < n ? VK_INCOMPLETE : VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, + VkExtensionProperties *pProperties) +{ + if (pLayerName) return VK_ERROR_LAYER_NOT_PRESENT; + static VkExtensionProperties *list; + static uint32_t count; + static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; + pthread_mutex_lock(&lock); + if (!list) { + if (!vkb_connected()) { + /* No server: offer nothing, and vkCreateInstance will say the driver is incompatible. */ + pthread_mutex_unlock(&lock); + *pPropertyCount = 0; + return VK_SUCCESS; + } + uint32_t n = 0; + vkb_wire_vkEnumerateInstanceExtensionProperties(NULL, &n, NULL); + VkExtensionProperties *srv = calloc(n + 1, sizeof(*srv)); + vkb_wire_vkEnumerateInstanceExtensionProperties(NULL, &n, srv); + size_t nc = sizeof(client_instance_exts) / sizeof(client_instance_exts[0]); + list = calloc(n + nc, sizeof(*list)); + for (uint32_t i = 0; i < n; i++) + if (bridged_ext(srv[i].extensionName, 0)) list[count++] = srv[i]; + for (size_t i = 0; i < nc; i++) { + snprintf(list[count].extensionName, sizeof(list[count].extensionName), "%s", client_instance_exts[i]); + list[count].specVersion = 1; + if (!strcmp(client_instance_exts[i], "VK_KHR_surface")) list[count].specVersion = 25; + if (!strcmp(client_instance_exts[i], "VK_KHR_wayland_surface")) list[count].specVersion = 6; + if (!strcmp(client_instance_exts[i], "VK_KHR_xcb_surface")) list[count].specVersion = 6; + if (!strcmp(client_instance_exts[i], "VK_KHR_xlib_surface")) list[count].specVersion = 6; + if (!strcmp(client_instance_exts[i], "VK_EXT_swapchain_colorspace")) list[count].specVersion = 4; + if (!strcmp(client_instance_exts[i], "VK_EXT_debug_utils")) list[count].specVersion = 2; + count++; + } + free(srv); + } + pthread_mutex_unlock(&lock); + return fill_props(list, count, pPropertyCount, pProperties); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties) +{ + (void)pProperties; + *pPropertyCount = 0; + return VK_SUCCESS; +} + +static int is_client_instance_ext(const char *n) +{ + for (size_t i = 0; i < sizeof(client_instance_exts) / sizeof(client_instance_exts[0]); i++) + if (!strcmp(client_instance_exts[i], n)) return 1; + return 0; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, + VkInstance *pInstance) +{ + (void)pAllocator; + if (!vkb_connected()) return VK_ERROR_INCOMPATIBLE_DRIVER; + vkb_instance *inst = calloc(1, sizeof(*inst)); + if (!inst) return VK_ERROR_OUT_OF_HOST_MEMORY; + inst->obj.loader.loaderMagic = ICD_LOADER_MAGIC; + inst->obj.type = VK_OBJECT_TYPE_INSTANCE; + pthread_mutex_init(&inst->lock, NULL); + + VkInstanceCreateInfo ci = *pCreateInfo; + const char **exts = calloc(ci.enabledExtensionCount + 1, sizeof(char *)); + uint32_t n = 0; + for (uint32_t i = 0; i < ci.enabledExtensionCount; i++) { + const char *e = ci.ppEnabledExtensionNames[i]; + if (is_client_instance_ext(e)) { + if (!strcmp(e, "VK_KHR_surface")) inst->ext_surface = 1; + else if (!strcmp(e, "VK_KHR_wayland_surface")) inst->ext_wayland = 1; + else if (!strcmp(e, "VK_KHR_xcb_surface")) inst->ext_xcb = 1; + else if (!strcmp(e, "VK_KHR_xlib_surface")) inst->ext_xlib = 1; + else if (!strcmp(e, "VK_EXT_headless_surface")) inst->ext_headless = 1; + else if (!strcmp(e, "VK_KHR_get_surface_capabilities2")) inst->ext_surface_caps2 = 1; + else if (!strcmp(e, "VK_EXT_debug_utils")) inst->ext_debug_utils = 1; + continue; + } + exts[n++] = e; + } + ci.enabledExtensionCount = n; + ci.ppEnabledExtensionNames = exts; + ci.enabledLayerCount = 0; + ci.ppEnabledLayerNames = NULL; + VkApplicationInfo app; + uint32_t api = server_instance_version(); + 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; + } else { + inst->api_version = VK_API_VERSION_1_0; + } + + vkb_call c; + vkb_call_begin(&c, VKB_CMD_vkCreateInstance, 0); + vkb_enc_u8(&c.e, 1); + vkb_enc_VkInstanceCreateInfo(&c.e, &ci); + vkb_enc_u8(&c.e, 1); + free(exts); + if (!vkb_call_exec(&c)) { + free(inst); + return VK_ERROR_INITIALIZATION_FAILED; + } + VkResult r = (VkResult)vkb_dec_u32(&c.d); + inst->obj.remote = vkb_dec_u64(&c.d); + inst->obj.table = vkb_dec_u32(&c.d); + vkb_call_end(&c); + if (r != VK_SUCCESS) { + free(inst); + return r; + } + VKB_INFO("instance created (Vulkan %u.%u)", VK_API_VERSION_MAJOR(inst->api_version), VK_API_VERSION_MINOR(inst->api_version)); + *pInstance = (VkInstance)inst; + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) +{ + (void)pAllocator; + if (!instance) return; + vkb_instance *inst = vkb_inst(instance); + vkb_call c; + vkb_call_begin(&c, VKB_CMD_vkDestroyInstance, inst->obj.table); + vkb_enc_u64(&c.e, inst->obj.remote); + if (vkb_call_exec(&c)) vkb_call_end(&c); + vkb_physdev *pd = inst->pds; + while (pd) { + vkb_physdev *n = pd->list_next; + free(pd->exts); + pthread_mutex_destroy(&pd->lock); + free(pd); + pd = n; + } + pthread_mutex_destroy(&inst->lock); + free(inst); +} + +/* ------------------------------------------------------------------ physical devices */ + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pCount, VkPhysicalDevice *pDevices) +{ + VkResult r = vkb_wire_vkEnumeratePhysicalDevices(instance, pCount, pDevices); + if (pDevices && (r == VK_SUCCESS || r == VK_INCOMPLETE)) { + for (uint32_t i = 0; i < *pCount; i++) vkb_physdev_ready(vkb_pd(pDevices[i])); + } + return r; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pCount, + VkPhysicalDeviceGroupProperties *pGroups) +{ + /* One group per device: what a single-GPU driver reports. */ + uint32_t n = 0; + VkResult r = vkb_ep_vkEnumeratePhysicalDevices(instance, &n, NULL); + if (r != VK_SUCCESS) return r; + if (!pGroups) { + *pCount = n; + return VK_SUCCESS; + } + VkPhysicalDevice *pds = calloc(n ? n : 1, sizeof(*pds)); + r = vkb_ep_vkEnumeratePhysicalDevices(instance, &n, pds); + uint32_t c = *pCount < n ? *pCount : n; + for (uint32_t i = 0; i < c; i++) { + pGroups[i].physicalDeviceCount = 1; + memset(pGroups[i].physicalDevices, 0, sizeof(pGroups[i].physicalDevices)); + pGroups[i].physicalDevices[0] = pds[i]; + pGroups[i].subsetAllocation = VK_FALSE; + } + free(pds); + *pCount = c; + return c < n ? VK_INCOMPLETE : r; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, + uint32_t *pPropertyCount, VkExtensionProperties *pProperties) +{ + if (pLayerName) return VK_ERROR_LAYER_NOT_PRESENT; + vkb_physdev *pd = vkb_pd(physicalDevice); + if (!vkb_physdev_ready(pd)) { + *pPropertyCount = 0; + return VK_SUCCESS; + } + return fill_props(pd->exts, pd->next, pPropertyCount, pProperties); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, + VkLayerProperties *pProperties) +{ + (void)physicalDevice; + (void)pProperties; + *pPropertyCount = 0; + return VK_SUCCESS; +} + +/* ------------------------------------------------------------------ device */ + +static const char *const client_device_exts[] = { + "VK_KHR_swapchain", "VK_KHR_incremental_present", "VK_KHR_swapchain_mutable_format", +}; + +int vkb_is_client_device_ext(const char *n) +{ + for (size_t i = 0; i < sizeof(client_device_exts) / sizeof(client_device_exts[0]); i++) + if (!strcmp(client_device_exts[i], n)) return 1; + return 0; +} + +const char *const *vkb_client_device_exts(uint32_t *n) +{ + *n = sizeof(client_device_exts) / sizeof(client_device_exts[0]); + return client_device_exts; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) +{ + (void)pAllocator; + vkb_physdev *pd = vkb_pd(physicalDevice); + if (!vkb_physdev_ready(pd)) return VK_ERROR_INITIALIZATION_FAILED; + vkb_device *dev = calloc(1, sizeof(*dev)); + if (!dev) return VK_ERROR_OUT_OF_HOST_MEMORY; + dev->obj.loader.loaderMagic = ICD_LOADER_MAGIC; + dev->obj.type = VK_OBJECT_TYPE_DEVICE; + dev->pd = pd; + dev->instance = pd->instance; + pthread_mutex_init(&dev->lock, NULL); + + VkDeviceCreateInfo ci = *pCreateInfo; + const char **server_exts = calloc(ci.enabledExtensionCount + 1, sizeof(char *)); + dev->enabled_exts = calloc(ci.enabledExtensionCount + 1, sizeof(char *)); + uint32_t n = 0; + for (uint32_t i = 0; i < ci.enabledExtensionCount; i++) { + const char *e = ci.ppEnabledExtensionNames[i]; + dev->enabled_exts[dev->enabled_ext_count++] = strdup(e); + if (!strcmp(e, "VK_KHR_swapchain")) dev->ext_swapchain = 1; + if (vkb_is_client_device_ext(e)) continue; + server_exts[n++] = e; + } + ci.enabledExtensionCount = n; + ci.ppEnabledExtensionNames = server_exts; + ci.enabledLayerCount = 0; + ci.ppEnabledLayerNames = NULL; + + vkb_call c; + vkb_call_begin(&c, VKB_CMD_vkCreateDevice, pd->obj.table); + vkb_enc_u64(&c.e, pd->obj.remote); + vkb_enc_u8(&c.e, 1); + vkb_enc_VkDeviceCreateInfo(&c.e, &ci); + vkb_enc_u8(&c.e, 1); + free(server_exts); + VkResult r; + if (!vkb_call_exec(&c)) { + r = VK_ERROR_INITIALIZATION_FAILED; + } else { + r = (VkResult)vkb_dec_u32(&c.d); + dev->obj.remote = vkb_dec_u64(&c.d); + dev->obj.table = vkb_dec_u32(&c.d); + vkb_call_end(&c); + } + if (r != VK_SUCCESS) { + for (uint32_t i = 0; i < dev->enabled_ext_count; i++) free((void *)dev->enabled_exts[i]); + free(dev->enabled_exts); + free(dev); + return r; + } + vkb_map_init(&dev->memories); + vkb_map_init(&dev->templates); + vkb_map_init(&dev->pools); + vkb_map_init(&dev->unshared); + vkb_map_init(&dev->shared_images); + vkb_memory_init_device(dev); + VKB_INFO("device created on %s", pd->props.deviceName); + *pDevice = (VkDevice)dev; + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) +{ + (void)pAllocator; + if (!device) return; + vkb_device *dev = vkb_dev(device); + vkb_call c; + vkb_call_begin(&c, VKB_CMD_vkDestroyDevice, dev->obj.table); + vkb_enc_u64(&c.e, dev->obj.remote); + if (vkb_call_exec(&c)) vkb_call_end(&c); + vkb_queue *q = dev->queues; + while (q) { + vkb_queue *n = q->next; + free(q); + q = n; + } + /* Mapped memory the app never freed. */ + for (uint32_t i = 0; i < dev->memories.cap; i++) { + if (dev->memories.keys[i] && dev->memories.keys[i] != ~(uint64_t)0) { + vkb_memory *m = dev->memories.vals[i]; + extern void vkb_memory_unmap_free(vkb_memory * m); + vkb_memory_unmap_free(m); + } + } + for (uint32_t i = 0; i < dev->pools.cap; i++) { + if (dev->pools.keys[i] && dev->pools.keys[i] != ~(uint64_t)0) { + extern void vkb_cmdpool_free(vkb_cmdpool * p); + vkb_cmdpool_free(dev->pools.vals[i]); + } + } + for (uint32_t i = 0; i < dev->templates.cap; i++) + if (dev->templates.keys[i] && dev->templates.keys[i] != ~(uint64_t)0) free(dev->templates.vals[i]); + vkb_map_destroy(&dev->memories); + vkb_map_destroy(&dev->templates); + vkb_map_destroy(&dev->pools); + vkb_map_destroy(&dev->unshared); + vkb_map_destroy(&dev->shared_images); + for (uint32_t i = 0; i < dev->enabled_ext_count; i++) free((void *)dev->enabled_exts[i]); + free(dev->enabled_exts); + pthread_mutex_destroy(&dev->lock); + free(dev); +} + +static void queue_set_info(VkQueue q, uint32_t family, uint32_t index) +{ + if (!q) return; + vkb_queue *vq = (vkb_queue *)q; + vq->family = family; + vq->index = index; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) +{ + vkb_wire_vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); + queue_set_info(*pQueue, queueFamilyIndex, queueIndex); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) +{ + vkb_wire_vkGetDeviceQueue2(device, pQueueInfo, pQueue); + queue_set_info(*pQueue, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex); +} + +/* ------------------------------------------------------------------ queues and sync */ + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) +{ + return vkb_wire_vkQueueSubmit(queue, submitCount, pSubmits, fence); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence) +{ + return vkb_wire_vkQueueSubmit2(queue, submitCount, pSubmits, fence); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueWaitIdle(VkQueue queue) +{ + return vkb_wire_vkQueueWaitIdle(queue); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkDeviceWaitIdle(VkDevice device) +{ + return vkb_wire_vkDeviceWaitIdle(device); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, + uint64_t timeout) +{ + return vkb_wire_vkWaitForFences(device, fenceCount, pFences, waitAll, timeout); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetFenceStatus(VkDevice device, VkFence fence) +{ + return vkb_wire_vkGetFenceStatus(device, fence); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout) +{ + return vkb_wire_vkWaitSemaphores(device, pWaitInfo, timeout); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) +{ + return vkb_wire_vkGetSemaphoreCounterValue(device, semaphore, pValue); +} diff --git a/tools/vkbridge/client/memory.c b/tools/vkbridge/client/memory.c new file mode 100644 index 000000000..ddc048126 --- /dev/null +++ b/tools/vkbridge/client/memory.c @@ -0,0 +1,433 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Device memory on the client side: the memory-type translation of physdev.c applied to every + * allocation and requirement, and mapping of shared allocations (server_memory.c explains how + * they are shared). + */ +#define _GNU_SOURCE +#include "vkb_client.h" +#include "gen/vkb_client_gen.h" +#include "emu.h" + +#include +#include +#include +#include + +void vkb_memory_init_device(vkb_device *d) +{ + (void)d; +} + +void vkb_memory_unmap_free(vkb_memory *m) +{ + if (m->ptr) munmap(m->ptr, (size_t)m->size); + free(m); +} + +/* ------------------------------------------------------------------ resources */ + +/* Shallow copy of a pNext chain (known structures only), in one malloc'd block (*mem). */ +void *vkb_chain_clone(const void *pNext, void **mem) +{ + size_t total = 0; + for (const VkBaseInStructure *b = pNext; b; b = b->pNext) total += (vkb_struct_size(b->sType) + 15) & ~(size_t)15; + uint8_t *block = calloc(1, total ? total : 16); + *mem = block; + VkBaseOutStructure *head = NULL, *prev = NULL; + size_t off = 0; + for (const VkBaseInStructure *b = pNext; b; b = b->pNext) { + size_t sz = vkb_struct_size(b->sType); + if (!sz) continue; + VkBaseOutStructure *n = (VkBaseOutStructure *)(block + off); + memcpy(n, b, sz); + n->pNext = NULL; + off += (sz + 15) & ~(size_t)15; + if (prev) prev->pNext = n; + else head = n; + prev = n; + } + return head; +} + +static int can_share(vkb_device *dev) +{ + return dev->pd->info.strategy != VKB_MEM_NONE && dev->pd->info.buffer_handle_types; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) +{ + vkb_device *dev = vkb_dev(device); + if (!can_share(dev) || (pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT)) { + VkResult r = vkb_wire_vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer); + if (r == VK_SUCCESS) vkb_map_put(&dev->unshared, (uint64_t)*pBuffer, (void *)1); + return r; + } + /* Every buffer may be bound to shared memory: say so at creation, as the spec requires. */ + VkBufferCreateInfo ci = *pCreateInfo; + VkExternalMemoryBufferCreateInfo ext = {VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, ci.pNext, + dev->pd->info.buffer_handle_types}; + int had = 0; + for (VkBaseOutStructure *b = (VkBaseOutStructure *)ci.pNext; b; b = b->pNext) { + if (b->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO) had = 1; + } + VkResult r; + if (had) { + /* The app has its own external handle types: ours are added to a copy of its chain. */ + void *mem = NULL; + ci.pNext = vkb_chain_clone(ci.pNext, &mem); + for (VkBaseOutStructure *b = (VkBaseOutStructure *)ci.pNext; b; b = b->pNext) + if (b->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO) + ((VkExternalMemoryBufferCreateInfo *)b)->handleTypes |= dev->pd->info.buffer_handle_types; + r = vkb_wire_vkCreateBuffer(device, &ci, pAllocator, pBuffer); + free(mem); + if (r != VK_SUCCESS && r != VK_ERROR_OUT_OF_HOST_MEMORY && r != VK_ERROR_OUT_OF_DEVICE_MEMORY) { + r = vkb_wire_vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer); + if (r == VK_SUCCESS) vkb_map_put(&dev->unshared, (uint64_t)*pBuffer, (void *)1); + } + return r; + } + ci.pNext = &ext; + r = vkb_wire_vkCreateBuffer(device, &ci, pAllocator, pBuffer); + if (r != VK_SUCCESS && r != VK_ERROR_OUT_OF_HOST_MEMORY && r != VK_ERROR_OUT_OF_DEVICE_MEMORY) { + VKB_ONCE(VKB_LOG_WARN, "a buffer cannot be created shareable (%d); it gets device-only memory (logged once)", r); + r = vkb_wire_vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer); + if (r == VK_SUCCESS) vkb_map_put(&dev->unshared, (uint64_t)*pBuffer, (void *)1); + } + return r; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) +{ + if (!buffer) return; + vkb_map_remove(&vkb_dev(device)->unshared, (uint64_t)buffer); + vkb_wire_vkDestroyBuffer(device, buffer, pAllocator); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkImage *pImage) +{ + vkb_device *dev = vkb_dev(device); + VkImageCreateInfo ci = *pCreateInfo; + vkb_emu_image_create_info(dev, &ci); + /* Linear images may be mapped by the app: those get the shared handle type when allowed. */ + if (can_share(dev) && ci.tiling == VK_IMAGE_TILING_LINEAR && !(ci.flags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT)) { + int had = 0; + for (VkBaseOutStructure *b = (VkBaseOutStructure *)ci.pNext; b; b = b->pNext) + had |= b->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO; + if (!had) { + VkExternalMemoryImageCreateInfo ext = {VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, ci.pNext, + dev->pd->info.buffer_handle_types}; + VkImageCreateInfo c2 = ci; + c2.pNext = &ext; + VkResult r = vkb_wire_vkCreateImage(device, &c2, pAllocator, pImage); + if (r == VK_SUCCESS) { + vkb_map_put(&dev->shared_images, (uint64_t)*pImage, (void *)1); + vkb_emu_image_created(dev, pCreateInfo, *pImage); + return r; + } + } + } + VkResult r = vkb_wire_vkCreateImage(device, &ci, pAllocator, pImage); + if (r == VK_SUCCESS) vkb_emu_image_created(dev, pCreateInfo, *pImage); + return r; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) +{ + if (!image) return; + vkb_device *dev = vkb_dev(device); + vkb_map_remove(&dev->shared_images, (uint64_t)image); + vkb_emu_image_destroyed(dev, image); + vkb_wire_vkDestroyImage(device, image, pAllocator); +} + +/* ------------------------------------------------------------------ requirements */ + +static void fix_reqs(vkb_device *dev, VkMemoryRequirements *r, int allow_shared) +{ + r->memoryTypeBits = vkb_mem_bits_to_client(dev->pd, r->memoryTypeBits, allow_shared); +} + +static int buffer_shareable(vkb_device *dev, VkBuffer b) +{ + return can_share(dev) && !vkb_map_get(&dev->unshared, (uint64_t)b); +} + +static int image_shareable(vkb_device *dev, VkImage i) +{ + return vkb_map_get(&dev->shared_images, (uint64_t)i) != NULL; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pReq) +{ + vkb_wire_vkGetBufferMemoryRequirements(device, buffer, pReq); + fix_reqs(vkb_dev(device), pReq, buffer_shareable(vkb_dev(device), buffer)); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, + VkMemoryRequirements2 *pReq) +{ + vkb_wire_vkGetBufferMemoryRequirements2(device, pInfo, pReq); + fix_reqs(vkb_dev(device), &pReq->memoryRequirements, buffer_shareable(vkb_dev(device), pInfo->buffer)); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pReq) +{ + vkb_wire_vkGetImageMemoryRequirements(device, image, pReq); + fix_reqs(vkb_dev(device), pReq, image_shareable(vkb_dev(device), image)); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, + VkMemoryRequirements2 *pReq) +{ + vkb_wire_vkGetImageMemoryRequirements2(device, pInfo, pReq); + fix_reqs(vkb_dev(device), &pReq->memoryRequirements, image_shareable(vkb_dev(device), pInfo->image)); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, + VkMemoryRequirements2 *pReq) +{ + vkb_device *dev = vkb_dev(device); + if (!can_share(dev)) { + vkb_wire_vkGetDeviceBufferMemoryRequirements(device, pInfo, pReq); + fix_reqs(dev, &pReq->memoryRequirements, 0); + return; + } + VkBufferCreateInfo ci = *pInfo->pCreateInfo; + VkExternalMemoryBufferCreateInfo ext = {VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, ci.pNext, + dev->pd->info.buffer_handle_types}; + int had = 0; + for (VkBaseOutStructure *b = (VkBaseOutStructure *)ci.pNext; b; b = b->pNext) + had |= b->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO; + if (!had) ci.pNext = &ext; + VkDeviceBufferMemoryRequirements info = *pInfo; + info.pCreateInfo = &ci; + vkb_wire_vkGetDeviceBufferMemoryRequirements(device, &info, pReq); + fix_reqs(dev, &pReq->memoryRequirements, 1); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, + VkMemoryRequirements2 *pReq) +{ + vkb_device *dev = vkb_dev(device); + VkImageCreateInfo ci = *pInfo->pCreateInfo; + vkb_emu_image_create_info(dev, &ci); + VkDeviceImageMemoryRequirements info = *pInfo; + info.pCreateInfo = &ci; + vkb_wire_vkGetDeviceImageMemoryRequirements(device, &info, pReq); + fix_reqs(dev, &pReq->memoryRequirements, 0); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pCount, + VkSparseImageMemoryRequirements *pReq) +{ + vkb_wire_vkGetImageSparseMemoryRequirements(device, image, pCount, pReq); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, + uint32_t *pCount, VkSparseImageMemoryRequirements2 *pReq) +{ + vkb_wire_vkGetImageSparseMemoryRequirements2(device, pInfo, pCount, pReq); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, + uint32_t *pCount, VkSparseImageMemoryRequirements2 *pReq) +{ + vkb_wire_vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pCount, pReq); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, + VkMemoryFdPropertiesKHR *pProps) +{ + VkResult r = vkb_wire_vkGetMemoryFdPropertiesKHR(device, handleType, fd, pProps); + if (r == VK_SUCCESS) pProps->memoryTypeBits = vkb_mem_bits_to_client(vkb_dev(device)->pd, pProps->memoryTypeBits, 0); + return r; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize offset) +{ + return vkb_wire_vkBindBufferMemory(device, buffer, memory, offset); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindBufferMemory2(VkDevice device, uint32_t n, const VkBindBufferMemoryInfo *p) +{ + return vkb_wire_vkBindBufferMemory2(device, n, p); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize offset) +{ + return vkb_wire_vkBindImageMemory(device, image, memory, offset); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindImageMemory2(VkDevice device, uint32_t n, const VkBindImageMemoryInfo *p) +{ + return vkb_wire_vkBindImageMemory2(device, n, p); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, + VkSubresourceLayout *pLayout) +{ + vkb_wire_vkGetImageSubresourceLayout(device, image, pSubresource, pLayout); +} + +/* ------------------------------------------------------------------ allocation and mapping */ + +static void close_import_fds(const void *pNext) +{ + for (const VkBaseInStructure *b = pNext; b; b = b->pNext) { + if (b->sType == VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR) { + int fd = ((const VkImportMemoryFdInfoKHR *)b)->fd; + if (fd >= 0) close(fd); + } + } +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, + const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) +{ + (void)pAllocator; + vkb_device *dev = vkb_dev(device); + vkb_physdev *pd = dev->pd; + uint32_t ct = pAllocateInfo->memoryTypeIndex; + if (ct >= pd->client_mem.memoryTypeCount) return VK_ERROR_OUT_OF_DEVICE_MEMORY; + VkMemoryAllocateInfo ai = *pAllocateInfo; + ai.memoryTypeIndex = pd->type_map[ct].server_type; + int shared = pd->type_map[ct].shared; + /* An app-imported dma-buf/opaque fd keeps its own memory; it is not one of our shared pages. */ + for (const VkBaseInStructure *b = ai.pNext; b; b = b->pNext) + if (b->sType == VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR) shared = 0; + uint32_t strategy = pd->info.strategy; + int memfd = -1; + void *ptr = NULL; + if (shared && strategy == VKB_MEM_HOSTPTR) { + VkDeviceSize a = pd->info.import_alignment ? pd->info.import_alignment : 4096; + ai.allocationSize = (ai.allocationSize + a - 1) & ~(a - 1); + memfd = vkb_memfd("vkbridge-memory", (size_t)ai.allocationSize); + if (memfd < 0) return VK_ERROR_OUT_OF_HOST_MEMORY; + ptr = mmap(NULL, (size_t)ai.allocationSize, PROT_READ | PROT_WRITE, MAP_SHARED, memfd, 0); + if (ptr == MAP_FAILED) { + close(memfd); + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + } + vkb_call c; + vkb_call_begin(&c, VKB_CMD_vkAllocateMemory, dev->obj.table); + vkb_enc_u64(&c.e, dev->obj.remote); + vkb_enc_u8(&c.e, 1); + vkb_enc_VkMemoryAllocateInfo(&c.e, &ai); + vkb_enc_u32(&c.e, shared ? VKB_ALLOC_SHARED : VKB_ALLOC_PLAIN); + vkb_enc_fd(&c.e, memfd); + int ok = vkb_call_exec(&c); + if (memfd >= 0) close(memfd); + if (!ok) { + if (ptr) munmap(ptr, (size_t)ai.allocationSize); + return VK_ERROR_DEVICE_LOST; + } + VkResult r = (VkResult)vkb_dec_u32(&c.d); + VkDeviceMemory mem = (VkDeviceMemory)vkb_dec_u64(&c.d); + int fd = vkb_dec_fd(&c.d); + uint64_t size = vkb_dec_u64(&c.d); + vkb_call_end(&c); + if (r != VK_SUCCESS) { + if (ptr) munmap(ptr, (size_t)ai.allocationSize); + if (fd >= 0) close(fd); + return r; + } + /* The import succeeded: the fd the app handed over now belongs to the implementation, and the + * server holds its own copy. */ + close_import_fds(pAllocateInfo->pNext); + vkb_memory *m = calloc(1, sizeof(*m)); + m->client_type = ct; + m->shared = shared; + m->size = shared && strategy == VKB_MEM_HOSTPTR ? ai.allocationSize : size; + if (shared && strategy != VKB_MEM_HOSTPTR) { + if (fd < 0) { + VKB_ERR("shared allocation came back without its dma-buf"); + } else { + ptr = mmap(NULL, (size_t)m->size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (ptr == MAP_FAILED) { + VKB_ERR("cannot map shared memory (%llu bytes): %s", (unsigned long long)m->size, strerror(errno)); + ptr = NULL; + } + } + } + if (fd >= 0) close(fd); + m->ptr = ptr; + vkb_map_put(&dev->memories, (uint64_t)mem, m); + *pMemory = mem; + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) +{ + (void)pAllocator; + if (!memory) return; + vkb_device *dev = vkb_dev(device); + vkb_memory *m = vkb_map_remove(&dev->memories, (uint64_t)memory); + vkb_call c; + vkb_call_begin(&c, VKB_CMD_vkFreeMemory, dev->obj.table); + vkb_enc_u64(&c.e, dev->obj.remote); + vkb_enc_u64(&c.e, (uint64_t)memory); + if (vkb_call_exec(&c)) vkb_call_end(&c); + if (m) vkb_memory_unmap_free(m); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, + VkMemoryMapFlags flags, void **ppData) +{ + (void)size; + (void)flags; + vkb_memory *m = vkb_map_get(&vkb_dev(device)->memories, (uint64_t)memory); + if (!m || !m->ptr) { + VKB_ONCE(VKB_LOG_WARN, "vkMapMemory on memory that is not host-visible through the bridge (logged once)"); + *ppData = NULL; + return VK_ERROR_MEMORY_MAP_FAILED; + } + *ppData = (uint8_t *)m->ptr + offset; + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkUnmapMemory(VkDevice device, VkDeviceMemory memory) +{ + /* The mapping stays until vkFreeMemory: mapping again is free, and nothing else reuses it. */ + (void)device; + (void)memory; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR *pInfo, void **ppData) +{ + return vkb_ep_vkMapMemory(device, pInfo->memory, pInfo->offset, pInfo->size, pInfo->flags, ppData); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR *pInfo) +{ + (void)device; + (void)pInfo; + return VK_SUCCESS; +} + +static VkResult ranges_call(VkDevice device, uint32_t cmd, uint32_t n, const VkMappedMemoryRange *r) +{ + vkb_device *dev = vkb_dev(device); + vkb_call c; + vkb_call_begin(&c, cmd, dev->obj.table); + vkb_enc_u64(&c.e, dev->obj.remote); + vkb_enc_u32(&c.e, n); + for (uint32_t i = 0; i < n; i++) vkb_enc_VkMappedMemoryRange(&c.e, &r[i]); + if (!vkb_call_exec(&c)) return VK_ERROR_DEVICE_LOST; + VkResult res = (VkResult)vkb_dec_u32(&c.d); + vkb_call_end(&c); + return res; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkFlushMappedMemoryRanges(VkDevice device, uint32_t n, const VkMappedMemoryRange *r) +{ + return ranges_call(device, VKB_CMD_vkFlushMappedMemoryRanges, n, r); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t n, const VkMappedMemoryRange *r) +{ + return ranges_call(device, VKB_CMD_vkInvalidateMappedMemoryRanges, n, r); +} diff --git a/tools/vkbridge/client/physdev.c b/tools/vkbridge/client/physdev.c new file mode 100644 index 000000000..fc8f054ed --- /dev/null +++ b/tools/vkbridge/client/physdev.c @@ -0,0 +1,367 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Physical device queries: what the app sees is the server's GPU, with the bridge's memory + * model, its extension list and the features the server emulates. + */ +#define _GNU_SOURCE +#include "vkb_client.h" +#include "gen/vkb_client_gen.h" +#include "emu.h" + +#include +#include + +const char *const *vkb_client_device_exts(uint32_t *n); + +/* ------------------------------------------------------------------ memory model */ + +/* + * Images and GPU-only buffers live in memory the client never maps; host-visible memory must be + * shared pages (server_memory.c), which only buffers (and the rare linear image) can use. So the + * app gets a discrete-GPU-like view: device-local types without host access, and host-visible + * types (shared) that only resources able to use them list in their memoryTypeBits. + */ +static void build_memory_model(vkb_physdev *pd) +{ + const VkPhysicalDeviceMemoryProperties *s = &pd->server_mem; + VkPhysicalDeviceMemoryProperties *c = &pd->client_mem; + memset(c, 0, sizeof(*c)); + uint32_t share = pd->info.strategy != VKB_MEM_NONE ? pd->info.shareable_types : 0; + int pure_dl = -1; + for (uint32_t t = 0; t < s->memoryTypeCount; t++) { + VkMemoryPropertyFlags f = s->memoryTypes[t].propertyFlags; + if ((f & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) && !(f & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) && + !(f & VK_MEMORY_PROPERTY_PROTECTED_BIT)) { + pure_dl = (int)t; + break; + } + } + int uma = pure_dl < 0; + /* Heaps: the server's, plus (UMA) a host heap for shared types so they are not "device local". */ + for (uint32_t h = 0; h < s->memoryHeapCount; h++) { + c->memoryHeaps[h] = s->memoryHeaps[h]; + pd->heap_map[h] = h; + } + c->memoryHeapCount = s->memoryHeapCount; + uint32_t host_heap = UINT32_MAX; + + struct cand { + VkMemoryPropertyFlags flags; + uint32_t heap, server; + uint8_t shared; + } cands[VK_MAX_MEMORY_TYPES * 2]; + uint32_t nc = 0; + if (uma) { + /* A device-local type with no host access, backed by the first device-local type. */ + for (uint32_t t = 0; t < s->memoryTypeCount; t++) { + VkMemoryPropertyFlags f = s->memoryTypes[t].propertyFlags; + if ((f & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) && !(f & VK_MEMORY_PROPERTY_PROTECTED_BIT)) { + cands[nc++] = (struct cand){VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, s->memoryTypes[t].heapIndex, t, 0}; + break; + } + } + } + for (uint32_t t = 0; t < s->memoryTypeCount && nc < VK_MAX_MEMORY_TYPES; t++) { + VkMemoryPropertyFlags f = s->memoryTypes[t].propertyFlags; + uint32_t heap = s->memoryTypes[t].heapIndex; + if (!(f & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) { + cands[nc++] = (struct cand){f, heap, t, 0}; + continue; + } + if (!(share & (1u << t))) continue; /* host-visible but not shareable: not offered */ + VkMemoryPropertyFlags cf = f; + if (!(pd->info.coherent_types & (1u << t))) cf &= ~VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + if (uma) { + cf &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; + if (host_heap == UINT32_MAX && c->memoryHeapCount < VK_MAX_MEMORY_HEAPS) { + host_heap = c->memoryHeapCount++; + c->memoryHeaps[host_heap] = s->memoryHeaps[heap]; + c->memoryHeaps[host_heap].flags &= ~VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; + pd->heap_map[host_heap] = heap; + } + if (host_heap != UINT32_MAX) heap = host_heap; + } + /* Two client types with identical flags on one heap are pointless: keep the first. */ + int dup = 0; + for (uint32_t i = 0; i < nc; i++) dup |= cands[i].flags == cf && cands[i].heap == heap; + if (!dup) cands[nc++] = (struct cand){cf, heap, t, 1}; + } + /* Order: fewer property bits first, which satisfies the spec's subset ordering. */ + for (uint32_t i = 1; i < nc; i++) { + struct cand x = cands[i]; + uint32_t j = i; + while (j > 0 && __builtin_popcount(cands[j - 1].flags) > __builtin_popcount(x.flags)) { + cands[j] = cands[j - 1]; + j--; + } + cands[j] = x; + } + if (nc > VK_MAX_MEMORY_TYPES) nc = VK_MAX_MEMORY_TYPES; + c->memoryTypeCount = nc; + for (uint32_t i = 0; i < nc; i++) { + c->memoryTypes[i].propertyFlags = cands[i].flags; + c->memoryTypes[i].heapIndex = cands[i].heap; + pd->type_map[i].server_type = cands[i].server; + pd->type_map[i].shared = cands[i].shared; + } + for (uint32_t i = 0; i < nc; i++) + VKB_DBG("memory type %u: flags 0x%x heap %u -> server type %u%s", i, c->memoryTypes[i].propertyFlags, + c->memoryTypes[i].heapIndex, pd->type_map[i].server_type, pd->type_map[i].shared ? " (shared)" : ""); +} + +uint32_t vkb_mem_bits_to_client(vkb_physdev *pd, uint32_t server_bits, int allow_shared) +{ + uint32_t bits = 0; + for (uint32_t i = 0; i < pd->client_mem.memoryTypeCount; i++) { + if (!(server_bits & (1u << pd->type_map[i].server_type))) continue; + if (pd->type_map[i].shared && !allow_shared) continue; + bits |= 1u << i; + } + return bits; +} + +/* ------------------------------------------------------------------ setup */ + +static int bridged_device_ext(const char *name) +{ + for (int i = 0; i < VKB_EXT_COUNT; i++) + if (vkb_exts[i].device && !vkb_exts[i].client && !strcmp(vkb_exts[i].name, name)) return 1; + return 0; +} + +int vkb_physdev_ready(vkb_physdev *pd) +{ + if (pd->ready) return pd->ready > 0; + pthread_mutex_lock(&pd->lock); + if (pd->ready) { + pthread_mutex_unlock(&pd->lock); + return pd->ready > 0; + } + vkb_call c; + vkb_call_begin(&c, VKB_CMD_vkbQueryServer, pd->obj.table); + vkb_enc_u64(&c.e, pd->obj.remote); + if (!vkb_call_exec(&c)) { + pd->ready = -1; + pthread_mutex_unlock(&pd->lock); + return 0; + } + vkb_dec_raw_into(&c.d, &pd->info, sizeof(pd->info)); + vkb_call_end(&c); + vkb_wire_vkGetPhysicalDeviceProperties((VkPhysicalDevice)pd, &pd->props); + vkb_wire_vkGetPhysicalDeviceMemoryProperties((VkPhysicalDevice)pd, &pd->server_mem); + build_memory_model(pd); + + uint32_t n = 0; + vkb_wire_vkEnumerateDeviceExtensionProperties((VkPhysicalDevice)pd, NULL, &n, NULL); + VkExtensionProperties *srv = calloc(n + 1, sizeof(*srv)); + vkb_wire_vkEnumerateDeviceExtensionProperties((VkPhysicalDevice)pd, NULL, &n, srv); + uint32_t ncl = 0; + const char *const *cl = vkb_client_device_exts(&ncl); + uint32_t nemu = 0; + const VkExtensionProperties *emu = vkb_emu_extensions(pd, &nemu); + pd->exts = calloc(n + ncl + nemu + 1, sizeof(VkExtensionProperties)); + pd->next = 0; + for (uint32_t i = 0; i < n; i++) + if (bridged_device_ext(srv[i].extensionName)) pd->exts[pd->next++] = srv[i]; + for (uint32_t i = 0; i < nemu; i++) { + int dup = 0; + for (uint32_t j = 0; j < pd->next; j++) dup |= !strcmp(pd->exts[j].extensionName, emu[i].extensionName); + if (!dup) pd->exts[pd->next++] = emu[i]; + } + for (uint32_t i = 0; i < ncl; i++) { + VkExtensionProperties *e = &pd->exts[pd->next++]; + snprintf(e->extensionName, sizeof(e->extensionName), "%s", cl[i]); + e->specVersion = !strcmp(cl[i], "VK_KHR_swapchain") ? 70 : !strcmp(cl[i], "VK_KHR_incremental_present") ? 2 : 1; + } + free(srv); + VKB_INFO("%s: %u extensions offered, memory sharing %s, emulation 0x%x", pd->props.deviceName, pd->next, + vkb_mem_strategy_name(pd->info.strategy), pd->info.emu); + pd->ready = 1; + pthread_mutex_unlock(&pd->lock); + return 1; +} + +/* ------------------------------------------------------------------ properties */ + +static void patch_props(vkb_physdev *pd, VkPhysicalDeviceProperties *p) +{ + if (p->apiVersion > VKB_API_VERSION) p->apiVersion = VKB_API_VERSION; + (void)pd; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) +{ + vkb_physdev *pd = vkb_pd(physicalDevice); + if (vkb_physdev_ready(pd)) *pProperties = pd->props; + else vkb_wire_vkGetPhysicalDeviceProperties(physicalDevice, pProperties); + patch_props(pd, pProperties); + vkb_emu_patch_limits(pd, pProperties); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) +{ + vkb_physdev *pd = vkb_pd(physicalDevice); + vkb_wire_vkGetPhysicalDeviceProperties2(physicalDevice, pProperties); + patch_props(pd, &pProperties->properties); + vkb_emu_patch_limits(pd, &pProperties->properties); + for (VkBaseOutStructure *b = (VkBaseOutStructure *)pProperties->pNext; b; b = b->pNext) { + if (b->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES) { + VkPhysicalDeviceDriverProperties *d = (VkPhysicalDeviceDriverProperties *)b; + size_t l = strlen(d->driverInfo); + if (l + 12 < sizeof(d->driverInfo)) strcat(d->driverInfo, " (vkbridge)"); + } + vkb_emu_patch_properties_chain(pd, b); + } +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) +{ + vkb_wire_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures); + vkb_emu_patch_features(vkb_pd(physicalDevice), pFeatures); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) +{ + vkb_wire_vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures); + vkb_emu_patch_features(vkb_pd(physicalDevice), &pFeatures->features); + for (VkBaseOutStructure *b = (VkBaseOutStructure *)pFeatures->pNext; b; b = b->pNext) + vkb_emu_patch_features_chain(vkb_pd(physicalDevice), b); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties *pMemoryProperties) +{ + vkb_physdev *pd = vkb_pd(physicalDevice); + if (!vkb_physdev_ready(pd)) { + memset(pMemoryProperties, 0, sizeof(*pMemoryProperties)); + return; + } + *pMemoryProperties = pd->client_mem; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) +{ + vkb_physdev *pd = vkb_pd(physicalDevice); + VkPhysicalDeviceMemoryBudgetPropertiesEXT *budget = NULL; + for (VkBaseOutStructure *b = (VkBaseOutStructure *)pMemoryProperties->pNext; b; b = b->pNext) + if (b->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT) budget = (void *)b; + vkb_wire_vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); + if (!vkb_physdev_ready(pd)) return; + pMemoryProperties->memoryProperties = pd->client_mem; + if (budget) { + VkDeviceSize b[VK_MAX_MEMORY_HEAPS], u[VK_MAX_MEMORY_HEAPS]; + memcpy(b, budget->heapBudget, sizeof(b)); + memcpy(u, budget->heapUsage, sizeof(u)); + memset(budget->heapBudget, 0, sizeof(budget->heapBudget)); + memset(budget->heapUsage, 0, sizeof(budget->heapUsage)); + for (uint32_t h = 0; h < pd->client_mem.memoryHeapCount; h++) { + budget->heapBudget[h] = b[pd->heap_map[h]]; + budget->heapUsage[h] = u[pd->heap_map[h]]; + } + } +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, + VkQueueFamilyProperties *pProps) +{ + vkb_wire_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pProps); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pCount, + VkQueueFamilyProperties2 *pProps) +{ + vkb_wire_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pCount, pProps); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties *pFormatProperties) +{ + if (vkb_emu_format_properties(vkb_pd(physicalDevice), format, pFormatProperties, NULL)) return; + vkb_wire_vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties2 *pFormatProperties) +{ + if (vkb_emu_format_properties(vkb_pd(physicalDevice), format, &pFormatProperties->formatProperties, pFormatProperties)) return; + vkb_wire_vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, + VkImageType type, VkImageTiling tiling, + VkImageUsageFlags usage, VkImageCreateFlags flags, + VkImageFormatProperties *pProps) +{ + VkFormat real = vkb_emu_real_format(vkb_pd(physicalDevice), format, &usage, &flags); + return vkb_wire_vkGetPhysicalDeviceImageFormatProperties(physicalDevice, real, type, tiling, usage, flags, pProps); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2 *pInfo, + VkImageFormatProperties2 *pProps) +{ + VkPhysicalDeviceImageFormatInfo2 info = *pInfo; + info.format = vkb_emu_real_format(vkb_pd(physicalDevice), pInfo->format, &info.usage, &info.flags); + return vkb_wire_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, &info, pProps); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, + VkImageType type, VkSampleCountFlagBits samples, + VkImageUsageFlags usage, VkImageTiling tiling, + uint32_t *pCount, VkSparseImageFormatProperties *pProps) +{ + if (vkb_emu_is_emulated_format(vkb_pd(physicalDevice), format)) { + *pCount = 0; + return; + } + vkb_wire_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pCount, pProps); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2 *pInfo, + uint32_t *pCount, VkSparseImageFormatProperties2 *pProps) +{ + if (vkb_emu_is_emulated_format(vkb_pd(physicalDevice), pInfo->format)) { + *pCount = 0; + return; + } + vkb_wire_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pInfo, pCount, pProps); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, + VkPhysicalDeviceToolProperties *pToolProperties) +{ + (void)physicalDevice; + (void)pToolProperties; + *pToolCount = 0; + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo *pInfo, + VkExternalBufferProperties *pProps) +{ + vkb_wire_vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pInfo, pProps); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo *pInfo, + VkExternalSemaphoreProperties *pProps) +{ + vkb_wire_vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pInfo, pProps); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo *pInfo, + VkExternalFenceProperties *pProps) +{ + vkb_wire_vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pInfo, pProps); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT *pProps) +{ + vkb_wire_vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pProps); +} diff --git a/tools/vkbridge/client/vkb_client.h b/tools/vkbridge/client/vkb_client.h new file mode 100644 index 000000000..7ab42a93e --- /dev/null +++ b/tools/vkbridge/client/vkb_client.h @@ -0,0 +1,177 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * DroidDeck Vulkan bridge - client ICD (libvulkan_droidbridge.so, glibc). + * + * A Vulkan driver for the Vulkan loader inside the Linux session. It owns no GPU: every call is + * encoded and executed by the server (app/src/main/cpp/vkbridge) on the device's real driver. + * Command buffers are recorded locally and shipped at vkEndCommandBuffer; mapped memory is + * shared pages (see server_memory.c); presentation (WSI) is implemented here. + */ +#ifndef VKB_CLIENT_H +#define VKB_CLIENT_H + +#define VK_USE_PLATFORM_WAYLAND_KHR 1 +#define VK_USE_PLATFORM_XCB_KHR 1 +#define VK_USE_PLATFORM_XLIB_KHR 1 + +#include +#include +#include + +#include "vkb_wire.h" +#include "vkb_proto.h" +#include "vkb_log.h" +#include +#include + +#define VKB_EXPORT __attribute__((visibility("default"))) +#define VKB_API_VERSION VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) + +/* ------------------------------------------------------------------ small hash map (u64 -> ptr) */ +typedef struct vkb_map { + uint64_t *keys; + void **vals; + uint32_t cap, count; + pthread_mutex_t lock; +} vkb_map; +void vkb_map_init(vkb_map *m); +void vkb_map_destroy(vkb_map *m); +void vkb_map_put(vkb_map *m, uint64_t k, void *v); +void *vkb_map_get(vkb_map *m, uint64_t k); +void *vkb_map_remove(vkb_map *m, uint64_t k); + +/* ------------------------------------------------------------------ dispatchable objects */ +typedef struct vkb_object { + VK_LOADER_DATA loader; /* must be first: the loader keeps its dispatch pointer here */ + VkObjectType type; + uint64_t remote; /* the server's handle */ + uint32_t table; /* the server's dispatch table for calls on this object */ +} vkb_object; + +typedef struct vkb_mem_type_map { + uint32_t server_type; + uint8_t shared; +} vkb_mem_type_map; + +struct vkb_instance; + +typedef struct vkb_physdev { + vkb_object obj; + struct vkb_instance *instance; + vkb_server_pd_info info; + VkPhysicalDeviceProperties props; + VkPhysicalDeviceMemoryProperties server_mem; + VkPhysicalDeviceMemoryProperties client_mem; /* what the app sees */ + vkb_mem_type_map type_map[VK_MAX_MEMORY_TYPES]; + uint32_t heap_map[VK_MAX_MEMORY_HEAPS]; /* client heap -> server heap */ + VkExtensionProperties *exts; /* filtered device extensions */ + uint32_t next; + int ready; + pthread_mutex_t lock; + struct vkb_physdev *list_next; +} vkb_physdev; + +typedef struct vkb_instance { + vkb_object obj; + uint32_t api_version; + vkb_physdev *pds; + pthread_mutex_t lock; + uint8_t ext_surface, ext_wayland, ext_xcb, ext_xlib, ext_headless, ext_surface_caps2, ext_debug_utils; +} vkb_instance; + +struct vkb_queue; + +typedef struct vkb_device { + vkb_object obj; + vkb_physdev *pd; + vkb_instance *instance; + struct vkb_queue *queues; + pthread_mutex_t lock; + vkb_map memories; /* VkDeviceMemory -> vkb_memory* */ + vkb_map templates; /* VkDescriptorUpdateTemplate -> vkb_template* */ + vkb_map pools; /* VkCommandPool -> vkb_cmdpool* */ + vkb_map unshared; /* VkBuffer/VkImage that cannot live in shared memory -> (void*)1 */ + vkb_map shared_images; /* VkImage that may live in shared memory -> (void*)1 */ + const char **enabled_exts; + uint32_t enabled_ext_count; + uint8_t ext_swapchain; +} vkb_device; + +typedef struct vkb_queue { + vkb_object obj; + vkb_device *device; + uint32_t family, index, flags; + struct vkb_queue *next; +} vkb_queue; + +typedef struct vkb_cmdbuf { + vkb_object obj; + vkb_device *device; + VkCommandPool pool; + VkCommandBufferLevel level; + vkb_enc stream; + size_t entry; /* offset of the open entry's payload */ + int recording; + int broken; + struct vkb_cmdbuf *pool_next, *pool_prev; +} vkb_cmdbuf; + +typedef struct vkb_cmdpool { + vkb_cmdbuf *head; +} vkb_cmdpool; + +typedef struct vkb_memory { + void *ptr; /* client mapping (shared allocations) */ + VkDeviceSize size; + uint32_t client_type; + int shared; +} vkb_memory; + +static inline vkb_device *vkb_dev(VkDevice d) { return (vkb_device *)d; } +static inline vkb_physdev *vkb_pd(VkPhysicalDevice p) { return (vkb_physdev *)p; } +static inline vkb_instance *vkb_inst(VkInstance i) { return (vkb_instance *)i; } +static inline vkb_cmdbuf *vkb_cb(VkCommandBuffer c) { return (vkb_cmdbuf *)c; } + +/* ------------------------------------------------------------------ calls */ +typedef struct vkb_call { + vkb_enc e; + vkb_dec d; + uint32_t cmd, table, flags; + struct vkb_conn *conn; +} vkb_call; + +void vkb_call_begin(vkb_call *c, uint32_t cmd, uint32_t table); +/* Sends the request and waits for the reply. 0 = failed (the call is already released). */ +int vkb_call_exec(vkb_call *c); +void vkb_call_end(vkb_call *c); +uint32_t vkb_table_of(const void *dispatchable); +int vkb_connected(void); +/* Per-thread transport cleanup for fork children. */ +void vkb_conn_after_fork(void); + +/* Command streams (cmdbuf.c). */ +vkb_enc *vkb_cmd_record_begin(VkCommandBuffer cb, uint32_t cmd); +void vkb_cmd_record_end(VkCommandBuffer cb); + +/* Dispatchable objects created by the server (generated stubs call this). */ +void *vkb_wrap(VkObjectType type, const void *parent, uint64_t remote); + +/* physdev.c */ +int vkb_physdev_ready(vkb_physdev *pd); +uint32_t vkb_mem_bits_to_client(vkb_physdev *pd, uint32_t server_bits, int allow_shared); + +/* memory.c */ +void vkb_memory_init_device(vkb_device *d); + +/* icd.c */ +PFN_vkVoidFunction vkb_lookup_proc(const char *name, int level_max, vkb_device *dev, vkb_instance *inst); +int vkb_device_ext_enabled(const vkb_device *d, const char *name); + +/* memory.c */ +void *vkb_chain_clone(const void *pNext, void **mem); +int vkb_is_client_device_ext(const char *n); + +/* misc */ +int vkb_memfd(const char *name, size_t size); + +#endif diff --git a/tools/vkbridge/client/wsi.c b/tools/vkbridge/client/wsi.c new file mode 100644 index 000000000..9dc4273ef --- /dev/null +++ b/tools/vkbridge/client/wsi.c @@ -0,0 +1,756 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Surfaces and swapchains (backend-independent part). + */ +#define _GNU_SOURCE +#include "wsi.h" +#include "gen/vkb_client_gen.h" + +#include +#include +#include + +const VkSurfaceFormatKHR vkb_wsi_formats[] = { + {VK_FORMAT_B8G8R8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, + {VK_FORMAT_B8G8R8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, + {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, + {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, +}; +const uint32_t vkb_wsi_format_count = sizeof(vkb_wsi_formats) / sizeof(vkb_wsi_formats[0]); + +#define FOURCC(a, b, c, d) ((uint32_t)(a) | ((uint32_t)(b) << 8) | ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24)) + +uint32_t vkb_drm_format(VkFormat f) +{ + switch (f) { + case VK_FORMAT_B8G8R8A8_SRGB: + case VK_FORMAT_B8G8R8A8_UNORM: return FOURCC('A', 'R', '2', '4'); + case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_R8G8B8A8_UNORM: return FOURCC('A', 'B', '2', '4'); + default: return 0; + } +} + +static vkb_surface *surf(VkSurfaceKHR s) { return (vkb_surface *)(uintptr_t)s; } +static vkb_swapchain *chain(VkSwapchainKHR s) { return (vkb_swapchain *)(uintptr_t)s; } + +/* ------------------------------------------------------------------ surfaces */ + +static VkResult new_surface(enum vkb_surface_kind kind, VkSurfaceKHR *out, vkb_surface **ps) +{ + vkb_surface *s = calloc(1, sizeof(*s)); + if (!s) return VK_ERROR_OUT_OF_HOST_MEMORY; + s->kind = kind; + *ps = s; + *out = (VkSurfaceKHR)(uintptr_t)s; + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) +{ + (void)instance; + (void)pAllocator; + if (!vkb_wl_load()) return VK_ERROR_INITIALIZATION_FAILED; + vkb_surface *s; + VkResult r = new_surface(VKB_SURF_WAYLAND, pSurface, &s); + if (r == VK_SUCCESS) { + s->wl_display = pCreateInfo->display; + s->wl_surface = pCreateInfo->surface; + } + return r; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) +{ + (void)instance; + (void)pAllocator; + if (!vkb_xcb_load()) return VK_ERROR_INITIALIZATION_FAILED; + vkb_surface *s; + VkResult r = new_surface(VKB_SURF_XCB, pSurface, &s); + if (r == VK_SUCCESS) { + s->xcb_conn = pCreateInfo->connection; + s->xcb_window = pCreateInfo->window; + } + return r; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) +{ + (void)instance; + (void)pAllocator; + if (!vkb_xcb_load()) return VK_ERROR_INITIALIZATION_FAILED; + void *conn = vkb_xlib_to_xcb(pCreateInfo->dpy); + if (!conn) return VK_ERROR_INITIALIZATION_FAILED; + vkb_surface *s; + VkResult r = new_surface(VKB_SURF_XCB, pSurface, &s); + if (r == VK_SUCCESS) { + s->xcb_conn = conn; + s->xcb_window = (uint32_t)pCreateInfo->window; + } + return r; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) +{ + (void)instance; + (void)pCreateInfo; + (void)pAllocator; + vkb_surface *s; + return new_surface(VKB_SURF_HEADLESS, pSurface, &s); +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) +{ + (void)instance; + (void)pAllocator; + free(surf(surface)); +} + +VKAPI_ATTR VkBool32 VKAPI_CALL vkb_ep_vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, + struct wl_display *display) +{ + (void)physicalDevice; + (void)queueFamilyIndex; + (void)display; + return vkb_wl_load() ? VK_TRUE : VK_FALSE; +} + +VKAPI_ATTR VkBool32 VKAPI_CALL vkb_ep_vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, + xcb_connection_t *connection, xcb_visualid_t visual_id) +{ + (void)physicalDevice; + (void)queueFamilyIndex; + (void)connection; + (void)visual_id; + return vkb_xcb_load() ? VK_TRUE : VK_FALSE; +} + +VKAPI_ATTR VkBool32 VKAPI_CALL vkb_ep_vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, + Display *dpy, VisualID visualID) +{ + (void)physicalDevice; + (void)queueFamilyIndex; + (void)dpy; + (void)visualID; + return vkb_xcb_load() ? VK_TRUE : VK_FALSE; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, + VkSurfaceKHR surface, VkBool32 *pSupported) +{ + (void)surface; + /* Presentation is a copy or a hand-over after the queue's work: any queue that can do + * graphics or compute (or transfer) can present. */ + uint32_t n = 0; + vkb_wire_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &n, NULL); + VkQueueFamilyProperties *qp = calloc(n ? n : 1, sizeof(*qp)); + vkb_wire_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &n, qp); + *pSupported = queueFamilyIndex < n && + (qp[queueFamilyIndex].queueFlags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT)); + free(qp); + return VK_SUCCESS; +} + +static VkResult surface_extent(vkb_surface *s, VkExtent2D *e) +{ + switch (s->kind) { + case VKB_SURF_WAYLAND: return vkb_wl_surface_extent(s, e); + case VKB_SURF_XCB: return vkb_xcb_surface_extent(s, e); + default: + e->width = e->height = 0xFFFFFFFFu; + return VK_SUCCESS; + } +} + +static VkImageUsageFlags supported_usage(VkPhysicalDevice pd) +{ + VkImageUsageFlags u = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | + VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; + VkFormatProperties fp; + vkb_wire_vkGetPhysicalDeviceFormatProperties(pd, VK_FORMAT_B8G8R8A8_UNORM, &fp); + if (fp.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) u |= VK_IMAGE_USAGE_STORAGE_BIT; + return u; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR *c) +{ + vkb_surface *s = surf(surface); + memset(c, 0, sizeof(*c)); + VkResult r = surface_extent(s, &c->currentExtent); + if (r != VK_SUCCESS) return r; + c->minImageCount = s->kind == VKB_SURF_WAYLAND ? 3 : 2; + c->maxImageCount = 8; + c->minImageExtent = (VkExtent2D){1, 1}; + c->maxImageExtent = (VkExtent2D){16384, 16384}; + if (c->currentExtent.width != 0xFFFFFFFFu) { + c->minImageExtent = c->maxImageExtent = c->currentExtent; + if (!c->currentExtent.width || !c->currentExtent.height) c->minImageExtent = (VkExtent2D){0, 0}; + } + c->maxImageArrayLayers = 1; + c->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; + c->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; + c->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR | VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; + if (s->kind == VKB_SURF_WAYLAND) c->supportedCompositeAlpha |= VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR; + c->supportedUsageFlags = supported_usage(physicalDevice); + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR *pInfo, + VkSurfaceCapabilities2KHR *pCaps) +{ + VkResult r = vkb_ep_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pInfo->surface, &pCaps->surfaceCapabilities); + for (VkBaseOutStructure *b = (VkBaseOutStructure *)pCaps->pNext; b; b = b->pNext) { + if (b->sType == VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR) + ((VkSurfaceProtectedCapabilitiesKHR *)b)->supportsProtected = VK_FALSE; + } + return r; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t *pCount, VkSurfaceFormatKHR *pFormats) +{ + (void)physicalDevice; + (void)surface; + if (!pFormats) { + *pCount = vkb_wsi_format_count; + return VK_SUCCESS; + } + uint32_t n = *pCount < vkb_wsi_format_count ? *pCount : vkb_wsi_format_count; + memcpy(pFormats, vkb_wsi_formats, n * sizeof(*pFormats)); + *pCount = n; + return n < vkb_wsi_format_count ? VK_INCOMPLETE : VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR *pInfo, uint32_t *pCount, + VkSurfaceFormat2KHR *pFormats) +{ + (void)physicalDevice; + (void)pInfo; + if (!pFormats) { + *pCount = vkb_wsi_format_count; + return VK_SUCCESS; + } + uint32_t n = *pCount < vkb_wsi_format_count ? *pCount : vkb_wsi_format_count; + for (uint32_t i = 0; i < n; i++) pFormats[i].surfaceFormat = vkb_wsi_formats[i]; + *pCount = n; + return n < vkb_wsi_format_count ? VK_INCOMPLETE : VK_SUCCESS; +} + +static const VkPresentModeKHR present_modes[] = {VK_PRESENT_MODE_FIFO_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR}; + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t *pCount, VkPresentModeKHR *pModes) +{ + (void)physicalDevice; + (void)surface; + uint32_t total = 3; + if (!pModes) { + *pCount = total; + return VK_SUCCESS; + } + uint32_t n = *pCount < total ? *pCount : total; + memcpy(pModes, present_modes, n * sizeof(*pModes)); + *pCount = n; + return n < total ? VK_INCOMPLETE : VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t *pRectCount, VkRect2D *pRects) +{ + (void)physicalDevice; + if (!pRects) { + *pRectCount = 1; + return VK_SUCCESS; + } + if (*pRectCount < 1) return VK_INCOMPLETE; + VkExtent2D e; + surface_extent(surf(surface), &e); + if (e.width == 0xFFFFFFFFu) e = (VkExtent2D){16384, 16384}; + pRects[0] = (VkRect2D){{0, 0}, e}; + *pRectCount = 1; + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pCaps) +{ + (void)device; + memset(pCaps->presentMask, 0, sizeof(pCaps->presentMask)); + pCaps->presentMask[0] = 1; + pCaps->modes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR; + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR *pModes) +{ + (void)device; + (void)surface; + *pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR; + return VK_SUCCESS; +} + +/* ------------------------------------------------------------------ swapchain images */ + +static uint32_t pick_type(vkb_device *dev, uint32_t bits, VkMemoryPropertyFlags want) +{ + const VkPhysicalDeviceMemoryProperties *mp = &dev->pd->client_mem; + for (uint32_t i = 0; i < mp->memoryTypeCount; i++) + if ((bits & (1u << i)) && (mp->memoryTypes[i].propertyFlags & want) == want) return i; + for (uint32_t i = 0; i < mp->memoryTypeCount; i++) + if (bits & (1u << i)) return i; + return UINT32_MAX; +} + +static int pd_has_ext(vkb_physdev *pd, const char *name) +{ + for (uint32_t i = 0; i < pd->next; i++) + if (!strcmp(pd->exts[i].extensionName, name)) return 1; + return 0; +} + +/* One swapchain image: exported as a linear dma-buf when `dmabuf`, else an ordinary image. */ +static VkResult create_image(vkb_swapchain *sc, vkb_swap_image *img, int dmabuf) +{ + vkb_device *dev = sc->dev; + VkDevice device = (VkDevice)dev; + const VkSwapchainCreateInfoKHR *ci = &sc->info; + VkImageCreateInfo ici = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO}; + ici.imageType = VK_IMAGE_TYPE_2D; + ici.format = ci->imageFormat; + ici.extent = (VkExtent3D){ci->imageExtent.width, ci->imageExtent.height, 1}; + ici.mipLevels = 1; + ici.arrayLayers = ci->imageArrayLayers; + ici.samples = VK_SAMPLE_COUNT_1_BIT; + ici.tiling = VK_IMAGE_TILING_OPTIMAL; + ici.usage = ci->imageUsage | (sc->copy_present || !dmabuf ? VK_IMAGE_USAGE_TRANSFER_SRC_BIT : 0); + ici.sharingMode = ci->imageSharingMode; + ici.queueFamilyIndexCount = ci->queueFamilyIndexCount; + ici.pQueueFamilyIndices = ci->pQueueFamilyIndices; + ici.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + if (ci->flags & VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR) ici.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; + VkImageFormatListCreateInfo fl = {VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, NULL, sc->view_format_count, sc->view_formats}; + VkExternalMemoryImageCreateInfo ext = {VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, NULL, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT}; + uint64_t linear = 0; /* DRM_FORMAT_MOD_LINEAR */ + VkImageDrmFormatModifierListCreateInfoEXT mods = {VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, NULL, 1, &linear}; + const void *chain = NULL; + if (sc->view_format_count) { + fl.pNext = chain; + chain = &fl; + } + int use_mods = 0; + if (dmabuf) { + ext.pNext = chain; + chain = &ext; + if (pd_has_ext(dev->pd, "VK_EXT_image_drm_format_modifier")) { + mods.pNext = chain; + chain = &mods; + ici.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT; + use_mods = 1; + } else { + ici.tiling = VK_IMAGE_TILING_LINEAR; + } + } + ici.pNext = chain; + VkResult r = vkb_wire_vkCreateImage(device, &ici, NULL, &img->image); + if (r != VK_SUCCESS) return r; + VkMemoryRequirements req; + vkb_ep_vkGetImageMemoryRequirements(device, img->image, &req); + uint32_t type = pick_type(dev, req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + if (type == UINT32_MAX) return VK_ERROR_OUT_OF_DEVICE_MEMORY; + VkMemoryDedicatedAllocateInfo ded = {VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, NULL, img->image, VK_NULL_HANDLE}; + VkExportMemoryAllocateInfo exp = {VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, &ded, VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT}; + VkMemoryAllocateInfo ai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, dmabuf ? (const void *)&exp : (const void *)&ded, req.size, type}; + r = vkb_ep_vkAllocateMemory(device, &ai, NULL, &img->memory); + if (r != VK_SUCCESS) return r; + r = vkb_wire_vkBindImageMemory(device, img->image, img->memory, 0); + if (r != VK_SUCCESS) return r; + img->dmabuf_fd = -1; + if (dmabuf) { + VkMemoryGetFdInfoKHR gi = {VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, NULL, img->memory, VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT}; + r = vkb_wire_vkGetMemoryFdKHR(device, &gi, &img->dmabuf_fd); + if (r != VK_SUCCESS || img->dmabuf_fd < 0) return r != VK_SUCCESS ? r : VK_ERROR_INITIALIZATION_FAILED; + VkImageSubresource sub = {use_mods ? VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT : VK_IMAGE_ASPECT_COLOR_BIT, 0, 0}; + VkSubresourceLayout lay; + vkb_wire_vkGetImageSubresourceLayout(device, img->image, &sub, &lay); + img->stride = (uint32_t)lay.rowPitch; + img->offset = (uint32_t)lay.offset; + img->modifier = 0; + if (use_mods) { + VkImageDrmFormatModifierPropertiesEXT mp = {VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT}; + if (vkb_wire_vkGetImageDrmFormatModifierPropertiesEXT(device, img->image, &mp) == VK_SUCCESS) img->modifier = mp.drmFormatModifier; + } + } + return VK_SUCCESS; +} + +static void destroy_image(vkb_swapchain *sc, vkb_swap_image *img) +{ + VkDevice device = (VkDevice)sc->dev; + if (img->dmabuf_fd >= 0) close(img->dmabuf_fd); + if (img->image) vkb_ep_vkDestroyImage(device, img->image, NULL); + if (img->memory) vkb_ep_vkFreeMemory(device, img->memory, NULL); +} + +static VkResult create_staging(vkb_swapchain *sc) +{ + vkb_device *dev = sc->dev; + VkDevice device = (VkDevice)dev; + VkDeviceSize size = (VkDeviceSize)sc->info.imageExtent.width * sc->info.imageExtent.height * 4; + VkBufferCreateInfo bci = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, NULL, 0, size, VK_BUFFER_USAGE_TRANSFER_DST_BIT, + VK_SHARING_MODE_EXCLUSIVE, 0, NULL}; + VkResult r = vkb_ep_vkCreateBuffer(device, &bci, NULL, &sc->staging); + if (r != VK_SUCCESS) return r; + VkMemoryRequirements req; + vkb_ep_vkGetBufferMemoryRequirements(device, sc->staging, &req); + uint32_t type = pick_type(dev, req.memoryTypeBits, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT); + if (type == UINT32_MAX || !(dev->pd->client_mem.memoryTypes[type].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) + type = pick_type(dev, req.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); + if (type == UINT32_MAX || !(dev->pd->client_mem.memoryTypes[type].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) { + VKB_ERR("swapchain: no host-visible memory to read frames back into"); + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + VkMemoryAllocateInfo ai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, NULL, req.size, type}; + r = vkb_ep_vkAllocateMemory(device, &ai, NULL, &sc->staging_mem); + if (r != VK_SUCCESS) return r; + r = vkb_wire_vkBindBufferMemory(device, sc->staging, sc->staging_mem, 0); + if (r != VK_SUCCESS) return r; + void *p = NULL; + r = vkb_ep_vkMapMemory(device, sc->staging_mem, 0, VK_WHOLE_SIZE, 0, &p); + sc->staging_ptr = p; + sc->staging_size = size; + return r; +} + +static VkResult ensure_copy_cbs(vkb_swapchain *sc, uint32_t family) +{ + VkDevice device = (VkDevice)sc->dev; + if (sc->pool && sc->pool_family == family) return VK_SUCCESS; + if (sc->pool) { + vkb_ep_vkDestroyCommandPool(device, sc->pool, NULL); + sc->pool = VK_NULL_HANDLE; + } + VkCommandPoolCreateInfo pci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, NULL, 0, family}; + VkResult r = vkb_wire_vkCreateCommandPool(device, &pci, NULL, &sc->pool); + if (r != VK_SUCCESS) return r; + sc->pool_family = family; + VkCommandBufferAllocateInfo cai = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, NULL, sc->pool, VK_COMMAND_BUFFER_LEVEL_PRIMARY, sc->count}; + r = vkb_ep_vkAllocateCommandBuffers(device, &cai, sc->copy_cbs); + if (r != VK_SUCCESS) return r; + for (uint32_t i = 0; i < sc->count; i++) { + VkCommandBuffer cb = sc->copy_cbs[i]; + VkCommandBufferBeginInfo bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, 0, NULL}; + vkb_ep_vkBeginCommandBuffer(cb, &bi); + VkImageMemoryBarrier b = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, VK_ACCESS_MEMORY_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_QUEUE_FAMILY_IGNORED, + VK_QUEUE_FAMILY_IGNORED, sc->images[i].image, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}}; + vkb_wire_vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1, &b); + VkBufferImageCopy region = {0, 0, 0, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, + {sc->info.imageExtent.width, sc->info.imageExtent.height, 1}}; + vkb_wire_vkCmdCopyImageToBuffer(cb, sc->images[i].image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, sc->staging, 1, ®ion); + b.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT; + b.dstAccessMask = 0; + b.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + b.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; + VkMemoryBarrier hb = {VK_STRUCTURE_TYPE_MEMORY_BARRIER, NULL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT}; + vkb_wire_vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT | VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 1, + &hb, 0, NULL, 1, &b); + r = vkb_ep_vkEndCommandBuffer(cb); + if (r != VK_SUCCESS) return r; + } + return VK_SUCCESS; +} + +/* Waits (on the CPU) for the app's rendering into image `index`, reading it back when needed. */ +VkResult vkb_wsi_wait_rendering(vkb_swapchain *sc, VkQueue queue, uint32_t index, uint32_t nwait, const VkSemaphore *wait) +{ + VkDevice device = (VkDevice)sc->dev; + VkPipelineStageFlags *stages = alloca((nwait ? nwait : 1) * sizeof(VkPipelineStageFlags)); + for (uint32_t i = 0; i < nwait; i++) stages[i] = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; + VkSubmitInfo si = {VK_STRUCTURE_TYPE_SUBMIT_INFO, NULL, nwait, wait, stages, 0, NULL, 0, NULL}; + if (sc->copy_present) { + VkResult r = ensure_copy_cbs(sc, ((vkb_queue *)queue)->family); + if (r != VK_SUCCESS) return r; + si.commandBufferCount = 1; + si.pCommandBuffers = &sc->copy_cbs[index]; + } + VkResult r = vkb_wire_vkQueueSubmit(queue, 1, &si, sc->fence); + if (r != VK_SUCCESS) return r; + r = vkb_wire_vkWaitForFences(device, 1, &sc->fence, VK_TRUE, 10ull * 1000 * 1000 * 1000); + vkb_wire_vkResetFences(device, 1, &sc->fence); + if (r == VK_TIMEOUT) { + VKB_ERR("swapchain: a frame took more than 10 s to render"); + return VK_ERROR_DEVICE_LOST; + } + return r; +} + +/* ------------------------------------------------------------------ swapchain */ + +static void swapchain_free(vkb_swapchain *sc) +{ + VkDevice device = (VkDevice)sc->dev; + if (sc->backend && sc->backend->destroy) sc->backend->destroy(sc); + for (uint32_t i = 0; i < sc->count; i++) destroy_image(sc, &sc->images[i]); + if (sc->pool) vkb_ep_vkDestroyCommandPool(device, sc->pool, NULL); + if (sc->fence) vkb_wire_vkDestroyFence(device, sc->fence, NULL); + if (sc->staging) vkb_ep_vkDestroyBuffer(device, sc->staging, NULL); + if (sc->staging_mem) vkb_ep_vkFreeMemory(device, sc->staging_mem, NULL); + free(sc->images); + free(sc->copy_cbs); + free(sc->view_formats); + pthread_mutex_destroy(&sc->lock); + free(sc); +} + +static VkResult swapchain_build(vkb_swapchain *sc, int dmabuf) +{ + VkDevice device = (VkDevice)sc->dev; + sc->dmabuf = dmabuf; + for (uint32_t i = 0; i < sc->count; i++) { + VkResult r = create_image(sc, &sc->images[i], dmabuf); + if (r != VK_SUCCESS) return r; + sc->images[i].chain = sc; + } + if (sc->copy_present) { + VkResult r = create_staging(sc); + if (r != VK_SUCCESS) return r; + } + VkFenceCreateInfo fci = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; + VkResult r = vkb_wire_vkCreateFence(device, &fci, NULL, &sc->fence); + if (r != VK_SUCCESS) return r; + return sc->backend->init(sc); +} + +static void swapchain_teardown(vkb_swapchain *sc) +{ + VkDevice device = (VkDevice)sc->dev; + if (sc->backend && sc->backend->destroy) sc->backend->destroy(sc); + sc->bdata = NULL; + for (uint32_t i = 0; i < sc->count; i++) { + destroy_image(sc, &sc->images[i]); + memset(&sc->images[i], 0, sizeof(sc->images[i])); + sc->images[i].dmabuf_fd = -1; + } + if (sc->fence) vkb_wire_vkDestroyFence(device, sc->fence, NULL); + sc->fence = VK_NULL_HANDLE; + if (sc->staging) vkb_ep_vkDestroyBuffer(device, sc->staging, NULL); + if (sc->staging_mem) vkb_ep_vkFreeMemory(device, sc->staging_mem, NULL); + sc->staging = VK_NULL_HANDLE; + sc->staging_mem = VK_NULL_HANDLE; + sc->staging_ptr = NULL; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) +{ + (void)pAllocator; + vkb_device *dev = vkb_dev(device); + vkb_surface *s = surf(pCreateInfo->surface); + if (pCreateInfo->oldSwapchain) chain(pCreateInfo->oldSwapchain)->retired = 1; + vkb_swapchain *sc = calloc(1, sizeof(*sc)); + if (!sc) return VK_ERROR_OUT_OF_HOST_MEMORY; + pthread_mutex_init(&sc->lock, NULL); + sc->dev = dev; + sc->surface = s; + sc->info = *pCreateInfo; + sc->info.pNext = NULL; + sc->info.pQueueFamilyIndices = NULL; + sc->info.queueFamilyIndexCount = 0; + sc->info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; + for (const VkBaseInStructure *b = pCreateInfo->pNext; b; b = b->pNext) { + if (b->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO) { + const VkImageFormatListCreateInfo *fl = (const void *)b; + sc->view_formats = calloc(fl->viewFormatCount + 1, sizeof(VkFormat)); + memcpy(sc->view_formats, fl->pViewFormats, fl->viewFormatCount * sizeof(VkFormat)); + sc->view_format_count = fl->viewFormatCount; + } + } + sc->count = pCreateInfo->minImageCount < 2 ? 2 : pCreateInfo->minImageCount; + if (s->kind == VKB_SURF_WAYLAND && sc->count < 3) sc->count = 3; + sc->images = calloc(sc->count, sizeof(vkb_swap_image)); + sc->copy_cbs = calloc(sc->count, sizeof(VkCommandBuffer)); + for (uint32_t i = 0; i < sc->count; i++) sc->images[i].dmabuf_fd = -1; + VkResult r; + switch (s->kind) { + case VKB_SURF_WAYLAND: + sc->backend = &vkb_wsi_wayland_backend; + sc->copy_present = getenv("VKBRIDGE_WSI_SHM") != NULL; + r = swapchain_build(sc, !sc->copy_present); + if (r != VK_SUCCESS && !sc->copy_present) { + VKB_WARN("Wayland: no dma-buf presentation (%d); falling back to copies through shared memory", r); + swapchain_teardown(sc); + sc->copy_present = 1; + r = swapchain_build(sc, 0); + } + break; + case VKB_SURF_XCB: + sc->backend = &vkb_wsi_x11_backend; + sc->copy_present = 1; + r = swapchain_build(sc, 0); + break; + default: + sc->backend = &vkb_wsi_headless_backend; + r = swapchain_build(sc, 0); + break; + } + if (r != VK_SUCCESS) { + VKB_ERR("swapchain creation failed: %d", r); + swapchain_free(sc); + return r; + } + VKB_INFO("swapchain %ux%u format %d, %u images, %s", sc->info.imageExtent.width, sc->info.imageExtent.height, sc->info.imageFormat, + sc->count, sc->copy_present ? "presented by copy" : sc->dmabuf ? "presented as dma-bufs" : "headless"); + *pSwapchain = (VkSwapchainKHR)(uintptr_t)sc; + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) +{ + (void)pAllocator; + if (!swapchain) return; + vkb_swapchain *sc = chain(swapchain); + /* Images may still be in use by the GPU (present waits are CPU-side, so not by us). */ + vkb_wire_vkDeviceWaitIdle(device); + swapchain_free(sc); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pCount, VkImage *pImages) +{ + (void)device; + vkb_swapchain *sc = chain(swapchain); + if (!pImages) { + *pCount = sc->count; + return VK_SUCCESS; + } + uint32_t n = *pCount < sc->count ? *pCount : sc->count; + for (uint32_t i = 0; i < n; i++) pImages[i] = sc->images[i].image; + *pCount = n; + return n < sc->count ? VK_INCOMPLETE : VK_SUCCESS; +} + +/* Signals the app's semaphore/fence for an acquired image (no GPU work is involved). */ +static VkResult signal_acquire(vkb_device *dev, VkSemaphore sem, VkFence fence) +{ + VkDevice device = (VkDevice)dev; + if (sem) { + VkImportSemaphoreFdInfoKHR si = {VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, NULL, sem, VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, -1}; + VkResult r = vkb_wire_vkImportSemaphoreFdKHR(device, &si); + if (r != VK_SUCCESS) { + /* No sync-fd import: signal it with an empty submit. */ + if (!dev->queues) return VK_ERROR_SURFACE_LOST_KHR; + VkSubmitInfo s = {VK_STRUCTURE_TYPE_SUBMIT_INFO, NULL, 0, NULL, NULL, 0, NULL, 1, &sem}; + r = vkb_wire_vkQueueSubmit((VkQueue)dev->queues, 1, &s, fence); + return r; + } + } + if (fence) { + VkImportFenceFdInfoKHR fi = {VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, NULL, fence, VK_FENCE_IMPORT_TEMPORARY_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, -1}; + VkResult r = vkb_wire_vkImportFenceFdKHR(device, &fi); + if (r != VK_SUCCESS) { + if (!dev->queues) return VK_ERROR_SURFACE_LOST_KHR; + r = vkb_wire_vkQueueSubmit((VkQueue)dev->queues, 0, NULL, fence); + return r; + } + } + return VK_SUCCESS; +} + +static uint64_t now_ns(void) +{ + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (uint64_t)ts.tv_sec * 1000000000ull + (uint64_t)ts.tv_nsec; +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, + VkFence fence, uint32_t *pImageIndex) +{ + vkb_swapchain *sc = chain(swapchain); + if (sc->retired) return VK_ERROR_OUT_OF_DATE_KHR; + if (sc->status != VK_SUCCESS) return sc->status; + uint64_t deadline = timeout == UINT64_MAX ? UINT64_MAX : now_ns() + timeout; + for (;;) { + pthread_mutex_lock(&sc->lock); + for (uint32_t i = 0; i < sc->count; i++) { + if (!sc->images[i].busy && !sc->images[i].acquired) { + sc->images[i].acquired = 1; + pthread_mutex_unlock(&sc->lock); + VkResult r = signal_acquire(vkb_dev(device), semaphore, fence); + if (r != VK_SUCCESS) return r; + *pImageIndex = i; + return sc->status; + } + } + pthread_mutex_unlock(&sc->lock); + uint64_t now = now_ns(); + if (timeout == 0) return VK_NOT_READY; + if (now >= deadline) return VK_TIMEOUT; + VkResult r = sc->backend->wait_free(sc, deadline == UINT64_MAX ? UINT64_MAX : deadline - now); + if (r < 0) { + sc->status = r; + return r; + } + } +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pInfo, uint32_t *pImageIndex) +{ + return vkb_ep_vkAcquireNextImageKHR(device, pInfo->swapchain, pInfo->timeout, pInfo->semaphore, pInfo->fence, pImageIndex); +} + +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) +{ + const VkPresentRegionsKHR *regions = NULL; + for (const VkBaseInStructure *b = pPresentInfo->pNext; b; b = b->pNext) + if (b->sType == VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR) regions = (const void *)b; + VkResult worst = VK_SUCCESS; + for (uint32_t i = 0; i < pPresentInfo->swapchainCount; i++) { + vkb_swapchain *sc = chain(pPresentInfo->pSwapchains[i]); + uint32_t index = pPresentInfo->pImageIndices[i]; + VkResult r = sc->status; + if (index >= sc->count) r = VK_ERROR_OUT_OF_DATE_KHR; + if (r >= 0) { + r = vkb_wsi_wait_rendering(sc, queue, index, i == 0 ? pPresentInfo->waitSemaphoreCount : 0, pPresentInfo->pWaitSemaphores); + } + pthread_mutex_lock(&sc->lock); + if (index < sc->count) { + sc->images[index].acquired = 0; + sc->images[index].busy = sc->dmabuf && !sc->copy_present; + } + pthread_mutex_unlock(&sc->lock); + if (r >= 0) { + r = sc->backend->present(sc, index, regions && i < regions->swapchainCount ? ®ions->pRegions[i] : NULL); + sc->presents++; + } + if (r < 0) { + pthread_mutex_lock(&sc->lock); + if (index < sc->count) sc->images[index].busy = 0; + pthread_mutex_unlock(&sc->lock); + if (r == VK_ERROR_OUT_OF_DATE_KHR || r == VK_ERROR_SURFACE_LOST_KHR) sc->status = r; + } + if (r == VK_SUCCESS && sc->status == VK_SUBOPTIMAL_KHR) r = VK_SUBOPTIMAL_KHR; + if (pPresentInfo->pResults) pPresentInfo->pResults[i] = r; + if (r < 0 && (worst >= 0 || r == VK_ERROR_DEVICE_LOST)) worst = r; + else if (worst == VK_SUCCESS && r == VK_SUBOPTIMAL_KHR) worst = r; + } + return worst; +} + +/* ------------------------------------------------------------------ headless */ + +static VkResult hl_init(vkb_swapchain *sc) { (void)sc; return VK_SUCCESS; } +static VkResult hl_present(vkb_swapchain *sc, uint32_t i, const VkPresentRegionKHR *r) { (void)sc; (void)i; (void)r; return VK_SUCCESS; } +static VkResult hl_wait(vkb_swapchain *sc, uint64_t t) { (void)sc; (void)t; return VK_TIMEOUT; } +static void hl_destroy(vkb_swapchain *sc) { (void)sc; } +const vkb_wsi_backend vkb_wsi_headless_backend = {hl_init, hl_present, hl_wait, hl_destroy}; diff --git a/tools/vkbridge/client/wsi.h b/tools/vkbridge/client/wsi.h new file mode 100644 index 000000000..c1d3bde43 --- /dev/null +++ b/tools/vkbridge/client/wsi.h @@ -0,0 +1,99 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Window-system integration implemented by the bridge client: the server's GPU has no Linux + * window systems, so swapchains are built here from ordinary images and handed to the + * compositor as dma-bufs (Wayland, zwp_linux_dmabuf_v1) or copied out through shared memory + * (Wayland wl_shm, X11 PutImage), or not shown at all (VK_EXT_headless_surface). + */ +#ifndef VKB_WSI_H +#define VKB_WSI_H + +#include "vkb_client.h" + +struct wl_display; +struct wl_surface; + +enum vkb_surface_kind { VKB_SURF_WAYLAND, VKB_SURF_XCB, VKB_SURF_HEADLESS }; + +typedef struct vkb_surface { + enum vkb_surface_kind kind; + struct wl_display *wl_display; + struct wl_surface *wl_surface; + void *xcb_conn; /* xcb_connection_t* */ + uint32_t xcb_window; + struct vkb_wl_display_info *wl_info; /* cached formats/modifiers per wl_display */ +} vkb_surface; + +typedef struct vkb_swapchain vkb_swapchain; + +typedef struct vkb_swap_image { + VkImage image; + VkDeviceMemory memory; + int busy; /* held by the compositor (or acquired by the app) */ + int acquired; + void *backend; /* backend per-image data (wl_buffer...) */ + uint32_t stride, offset; + uint64_t modifier; + int dmabuf_fd; + vkb_swapchain *chain; +} vkb_swap_image; + +typedef struct vkb_wsi_backend { + /* Called after images exist; may fail (e.g. no dma-buf support) - the generic code then + * retries with copy_present = 1. */ + VkResult (*init)(vkb_swapchain *sc); + /* The image's rendering is complete (and, with copy_present, its pixels are in sc->staging). */ + VkResult (*present)(vkb_swapchain *sc, uint32_t index, const VkPresentRegionKHR *region); + /* Wait until an image may be acquired (dispatching events); 0 timeout = poll. */ + VkResult (*wait_free)(vkb_swapchain *sc, uint64_t timeout_ns); + void (*destroy)(vkb_swapchain *sc); +} vkb_wsi_backend; + +struct vkb_swapchain { + vkb_device *dev; + vkb_surface *surface; + VkSwapchainCreateInfoKHR info; + VkFormat *view_formats; + uint32_t view_format_count; + uint32_t count; + vkb_swap_image *images; + const vkb_wsi_backend *backend; + void *bdata; + int dmabuf; /* images are exported dma-bufs */ + int copy_present; /* pixels are read back into `staging` at present */ + /* Read-back resources (copy_present). */ + VkBuffer staging; + VkDeviceMemory staging_mem; + uint8_t *staging_ptr; + VkDeviceSize staging_size; + VkCommandPool pool; + uint32_t pool_family; + VkCommandBuffer *copy_cbs; + VkFence fence; + VkResult status; /* VK_ERROR_OUT_OF_DATE_KHR / SURFACE_LOST once broken */ + pthread_mutex_t lock; + uint64_t presents; + int retired; +}; + +/* Formats every surface offers. */ +extern const VkSurfaceFormatKHR vkb_wsi_formats[]; +extern const uint32_t vkb_wsi_format_count; + +/* Wayland */ +extern const vkb_wsi_backend vkb_wsi_wayland_backend; +int vkb_wl_load(void); +VkResult vkb_wl_surface_extent(vkb_surface *s, VkExtent2D *e); +/* X11 */ +extern const vkb_wsi_backend vkb_wsi_x11_backend; +int vkb_xcb_load(void); +VkResult vkb_xcb_surface_extent(vkb_surface *s, VkExtent2D *e); +void *vkb_xlib_to_xcb(void *dpy); +/* Headless */ +extern const vkb_wsi_backend vkb_wsi_headless_backend; + +/* Helpers in wsi.c */ +uint32_t vkb_drm_format(VkFormat f); +VkResult vkb_wsi_wait_rendering(vkb_swapchain *sc, VkQueue queue, uint32_t index, uint32_t nwait, const VkSemaphore *wait); + +#endif diff --git a/tools/vkbridge/client/wsi_wayland.c b/tools/vkbridge/client/wsi_wayland.c new file mode 100644 index 000000000..4c828753a --- /dev/null +++ b/tools/vkbridge/client/wsi_wayland.c @@ -0,0 +1,558 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Wayland presentation. + * + * - dma-buf: swapchain images are linear exportable images; each becomes a wl_buffer through + * zwp_linux_dmabuf_v1 once, and a present is attach + commit (no copy). This is the path for + * gamescope (and its WSI layer, which turns X11 games' swapchains into Wayland ones). + * - wl_shm: for compositors without dma-buf (KWin compositing in software on the desktop): the + * frame is read back and copied into a shared-memory buffer. + * + * libwayland-client is opened at run time, so the driver loads in programs that never touch + * Wayland. Our objects live on a private event queue, like Mesa's WSI. + */ +#define _GNU_SOURCE +#include "wsi.h" +#include "gen/vkb_client_gen.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +/* ------------------------------------------------------------------ libwayland-client */ + +struct wl_proxy; +struct wl_event_queue; +struct wl_message { + const char *name; + const char *signature; + const struct wl_interface **types; +}; +struct wl_interface { + const char *name; + int version; + int method_count; + const struct wl_message *methods; + int event_count; + const struct wl_message *events; +}; + +static struct { + void *lib; + struct wl_proxy *(*proxy_marshal_constructor)(struct wl_proxy *, uint32_t, const struct wl_interface *, ...); + struct wl_proxy *(*proxy_marshal_constructor_versioned)(struct wl_proxy *, uint32_t, const struct wl_interface *, uint32_t, ...); + void (*proxy_marshal)(struct wl_proxy *, uint32_t, ...); + int (*proxy_add_listener)(struct wl_proxy *, void (**)(void), void *); + void (*proxy_destroy)(struct wl_proxy *); + void *(*proxy_create_wrapper)(void *); + void (*proxy_wrapper_destroy)(void *); + void (*proxy_set_queue)(struct wl_proxy *, struct wl_event_queue *); + uint32_t (*proxy_get_version)(struct wl_proxy *); + struct wl_event_queue *(*display_create_queue)(struct wl_display *); + void (*event_queue_destroy)(struct wl_event_queue *); + int (*display_roundtrip_queue)(struct wl_display *, struct wl_event_queue *); + int (*display_dispatch_queue_pending)(struct wl_display *, struct wl_event_queue *); + int (*display_prepare_read_queue)(struct wl_display *, struct wl_event_queue *); + int (*display_read_events)(struct wl_display *); + void (*display_cancel_read)(struct wl_display *); + int (*display_flush)(struct wl_display *); + int (*display_get_fd)(struct wl_display *); + int (*display_get_error)(struct wl_display *); + const struct wl_interface *registry_iface, *callback_iface, *buffer_iface, *shm_iface, *shm_pool_iface; +} wl; + +int vkb_wl_load(void) +{ + static int state; + static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; + pthread_mutex_lock(&lock); + if (!state) { + wl.lib = dlopen("libwayland-client.so.0", RTLD_NOW | RTLD_LOCAL); + state = -1; + if (wl.lib) { +#define L(f, n) (*(void **)&wl.f = dlsym(wl.lib, n)) + int ok = 1; + ok &= !!L(proxy_marshal_constructor, "wl_proxy_marshal_constructor"); + ok &= !!L(proxy_marshal_constructor_versioned, "wl_proxy_marshal_constructor_versioned"); + ok &= !!L(proxy_marshal, "wl_proxy_marshal"); + ok &= !!L(proxy_add_listener, "wl_proxy_add_listener"); + ok &= !!L(proxy_destroy, "wl_proxy_destroy"); + ok &= !!L(proxy_create_wrapper, "wl_proxy_create_wrapper"); + ok &= !!L(proxy_wrapper_destroy, "wl_proxy_wrapper_destroy"); + ok &= !!L(proxy_set_queue, "wl_proxy_set_queue"); + ok &= !!L(proxy_get_version, "wl_proxy_get_version"); + ok &= !!L(display_create_queue, "wl_display_create_queue"); + ok &= !!L(event_queue_destroy, "wl_event_queue_destroy"); + ok &= !!L(display_roundtrip_queue, "wl_display_roundtrip_queue"); + ok &= !!L(display_dispatch_queue_pending, "wl_display_dispatch_queue_pending"); + ok &= !!L(display_prepare_read_queue, "wl_display_prepare_read_queue"); + ok &= !!L(display_read_events, "wl_display_read_events"); + ok &= !!L(display_cancel_read, "wl_display_cancel_read"); + ok &= !!L(display_flush, "wl_display_flush"); + ok &= !!L(display_get_fd, "wl_display_get_fd"); + ok &= !!L(display_get_error, "wl_display_get_error"); + ok &= !!L(registry_iface, "wl_registry_interface"); + ok &= !!L(callback_iface, "wl_callback_interface"); + ok &= !!L(buffer_iface, "wl_buffer_interface"); + ok &= !!L(shm_iface, "wl_shm_interface"); + ok &= !!L(shm_pool_iface, "wl_shm_pool_interface"); +#undef L + if (ok) state = 1; + else VKB_ERR("libwayland-client lacks functions this driver needs"); + } else { + VKB_WARN("no libwayland-client: %s", dlerror()); + } + } + pthread_mutex_unlock(&lock); + return state > 0; +} + +/* zwp_linux_dmabuf_v1 / zwp_linux_buffer_params_v1, as wayland-scanner would emit them. */ +static const struct wl_interface params_iface; +static const struct wl_interface *dmabuf_types[8]; +static const struct wl_message dmabuf_requests[] = { + {"destroy", "", dmabuf_types + 0}, + {"create_params", "n", dmabuf_types + 6}, +}; +static const struct wl_message dmabuf_events[] = { + {"format", "u", dmabuf_types + 0}, + {"modifier", "3uuu", dmabuf_types + 0}, +}; +static const struct wl_interface dmabuf_iface = {"zwp_linux_dmabuf_v1", 3, 2, dmabuf_requests, 2, dmabuf_events}; +static const struct wl_message params_requests[] = { + {"destroy", "", dmabuf_types + 0}, + {"add", "huuuuu", dmabuf_types + 0}, + {"create", "iiuu", dmabuf_types + 0}, + {"create_immed", "2niiuu", dmabuf_types + 7}, +}; +static const struct wl_message params_events[] = { + {"created", "n", dmabuf_types + 7}, + {"failed", "", dmabuf_types + 0}, +}; +static const struct wl_interface params_iface = {"zwp_linux_buffer_params_v1", 3, 4, params_requests, 2, params_events}; + +static void init_types(void) +{ + /* types[0..5] stay NULL (no object arguments); [6] = params, [7] = wl_buffer */ + dmabuf_types[6] = ¶ms_iface; + dmabuf_types[7] = wl.buffer_iface; +} + +/* ------------------------------------------------------------------ per-swapchain state */ + +#define WL_DISPLAY_GET_REGISTRY 1 +#define WL_REGISTRY_BIND 0 +#define WL_SURFACE_ATTACH 1 +#define WL_SURFACE_DAMAGE 2 +#define WL_SURFACE_FRAME 3 +#define WL_SURFACE_COMMIT 6 +#define WL_SURFACE_DAMAGE_BUFFER 9 +#define WL_BUFFER_DESTROY 0 +#define WL_SHM_CREATE_POOL 0 +#define WL_SHM_POOL_CREATE_BUFFER 0 +#define WL_SHM_POOL_DESTROY 1 +#define DMABUF_DESTROY 0 +#define DMABUF_CREATE_PARAMS 1 +#define PARAMS_DESTROY 0 +#define PARAMS_ADD 1 +#define PARAMS_CREATE_IMMED 3 +#define WL_SHM_FORMAT_ARGB8888 0u +#define WL_SHM_FORMAT_XRGB8888 1u +#define FOURCC(a, b, c, d) ((uint32_t)(a) | ((uint32_t)(b) << 8) | ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24)) +#define DRM_XRGB8888 FOURCC('X', 'R', '2', '4') +#define DRM_ARGB8888 FOURCC('A', 'R', '2', '4') +#define DRM_XBGR8888 FOURCC('X', 'B', '2', '4') +#define DRM_ABGR8888 FOURCC('A', 'B', '2', '4') +#define MAX_FMTS 64 + +typedef struct shm_buf { + struct wl_proxy *buffer; + uint8_t *ptr; + int busy; +} shm_buf; + +typedef struct wl_state { + struct wl_display *display; + struct wl_event_queue *queue; + void *display_wrapper; + void *surface_wrapper; + struct wl_proxy *registry; + struct wl_proxy *shm; + struct wl_proxy *dmabuf; + uint32_t dmabuf_version; + uint32_t shm_formats[MAX_FMTS]; + int nshm; + struct { uint32_t format; uint64_t modifier; } dmabuf_mods[256]; + int nmods; + uint32_t dmabuf_formats[MAX_FMTS]; + int nformats; + struct wl_proxy **buffers; /* dma-buf wl_buffers, one per image */ + shm_buf *shm_bufs; + int nshm_bufs; + struct wl_proxy *shm_pool; + uint8_t *shm_map; + size_t shm_size; + uint32_t shm_stride, shm_format; + int swizzle; /* RGBA frame into an ARGB/XRGB shm buffer */ + struct wl_proxy *frame; /* pending frame callback */ + vkb_swapchain *sc; +} wl_state; + +static void registry_global(void *data, struct wl_proxy *reg, uint32_t name, const char *iface, uint32_t version) +{ + wl_state *s = data; + if (!strcmp(iface, "wl_shm") && !s->shm) { + s->shm = wl.proxy_marshal_constructor_versioned(reg, WL_REGISTRY_BIND, wl.shm_iface, 1, name, wl.shm_iface->name, 1, NULL); + } else if (!strcmp(iface, "zwp_linux_dmabuf_v1") && !s->dmabuf && version >= 2) { + uint32_t v = version < 3 ? version : 3; + s->dmabuf = wl.proxy_marshal_constructor_versioned(reg, WL_REGISTRY_BIND, &dmabuf_iface, v, name, dmabuf_iface.name, v, NULL); + s->dmabuf_version = v; + } +} + +static void registry_global_remove(void *data, struct wl_proxy *reg, uint32_t name) +{ + (void)data; + (void)reg; + (void)name; +} + +static const void *registry_listener[] = {(void *)registry_global, (void *)registry_global_remove}; + +static void shm_format(void *data, struct wl_proxy *shm, uint32_t format) +{ + (void)shm; + wl_state *s = data; + if (s->nshm < MAX_FMTS) s->shm_formats[s->nshm++] = format; +} + +static const void *shm_listener[] = {(void *)shm_format}; + +static void dmabuf_format(void *data, struct wl_proxy *d, uint32_t format) +{ + (void)d; + wl_state *s = data; + if (s->nformats < MAX_FMTS) s->dmabuf_formats[s->nformats++] = format; +} + +static void dmabuf_modifier(void *data, struct wl_proxy *d, uint32_t format, uint32_t hi, uint32_t lo) +{ + (void)d; + wl_state *s = data; + if (s->nmods < 256) { + s->dmabuf_mods[s->nmods].format = format; + s->dmabuf_mods[s->nmods].modifier = ((uint64_t)hi << 32) | lo; + s->nmods++; + } +} + +static const void *dmabuf_listener[] = {(void *)dmabuf_format, (void *)dmabuf_modifier}; + +static void buffer_release(void *data, struct wl_proxy *buffer) +{ + (void)buffer; + vkb_swap_image *img = data; + pthread_mutex_lock(&img->chain->lock); + img->busy = 0; + pthread_mutex_unlock(&img->chain->lock); +} + +static const void *buffer_listener[] = {(void *)buffer_release}; + +static void shm_buffer_release(void *data, struct wl_proxy *buffer) +{ + (void)buffer; + ((shm_buf *)data)->busy = 0; +} + +static const void *shm_buffer_listener[] = {(void *)shm_buffer_release}; + +static void frame_done(void *data, struct wl_proxy *cb, uint32_t t) +{ + (void)t; + wl_state *s = data; + if (s->frame == cb) s->frame = NULL; + wl.proxy_destroy(cb); +} + +static const void *frame_listener[] = {(void *)frame_done}; + +/* Dispatch our queue, waiting up to timeout_ns for events. -1 on a dead connection. */ +static int dispatch_timeout(wl_state *s, uint64_t timeout_ns) +{ + if (wl.display_dispatch_queue_pending(s->display, s->queue) < 0) return -1; + while (wl.display_prepare_read_queue(s->display, s->queue) != 0) { + if (wl.display_dispatch_queue_pending(s->display, s->queue) < 0) return -1; + } + if (wl.display_flush(s->display) < 0 && errno != EAGAIN) { + wl.display_cancel_read(s->display); + return -1; + } + struct pollfd p = {wl.display_get_fd(s->display), POLLIN, 0}; + int ms = timeout_ns == UINT64_MAX ? -1 : (int)((timeout_ns + 999999) / 1000000); + int r = poll(&p, 1, ms); + if (r <= 0) { + wl.display_cancel_read(s->display); + return r < 0 && errno != EINTR ? -1 : 0; + } + if (wl.display_read_events(s->display) < 0) return -1; + return wl.display_dispatch_queue_pending(s->display, s->queue) < 0 ? -1 : 1; +} + +static int has_u32(const uint32_t *a, int n, uint32_t v) +{ + for (int i = 0; i < n; i++) + if (a[i] == v) return 1; + return 0; +} + +static int dmabuf_supports(wl_state *s, uint32_t fourcc, uint64_t modifier) +{ + if (s->nmods) { + for (int i = 0; i < s->nmods; i++) { + /* DRM_FORMAT_MOD_INVALID means "implicit": treat as linear for our linear buffers. */ + if (s->dmabuf_mods[i].format == fourcc && + (s->dmabuf_mods[i].modifier == modifier || s->dmabuf_mods[i].modifier == 0x00ffffffffffffffull)) + return 1; + } + return 0; + } + return has_u32(s->dmabuf_formats, s->nformats, fourcc); +} + +/* ------------------------------------------------------------------ backend */ + +VkResult vkb_wl_surface_extent(vkb_surface *s, VkExtent2D *e) +{ + (void)s; + e->width = e->height = 0xFFFFFFFFu; + return VK_SUCCESS; +} + +static void wl_teardown(wl_state *s); + +static VkResult wl_init(vkb_swapchain *sc) +{ + vkb_surface *surface = sc->surface; + wl_state *s = calloc(1, sizeof(*s)); + sc->bdata = s; + s->sc = sc; + s->display = surface->wl_display; + init_types(); + s->queue = wl.display_create_queue(s->display); + s->display_wrapper = wl.proxy_create_wrapper(s->display); + wl.proxy_set_queue(s->display_wrapper, s->queue); + s->surface_wrapper = wl.proxy_create_wrapper(surface->wl_surface); + wl.proxy_set_queue(s->surface_wrapper, s->queue); + s->registry = wl.proxy_marshal_constructor(s->display_wrapper, WL_DISPLAY_GET_REGISTRY, wl.registry_iface, NULL); + wl.proxy_add_listener(s->registry, (void (**)(void))registry_listener, s); + if (wl.display_roundtrip_queue(s->display, s->queue) < 0) return VK_ERROR_SURFACE_LOST_KHR; + if (s->shm) wl.proxy_add_listener(s->shm, (void (**)(void))shm_listener, s); + if (s->dmabuf) wl.proxy_add_listener(s->dmabuf, (void (**)(void))dmabuf_listener, s); + if (wl.display_roundtrip_queue(s->display, s->queue) < 0) return VK_ERROR_SURFACE_LOST_KHR; + + uint32_t w = sc->info.imageExtent.width, h = sc->info.imageExtent.height; + int opaque = sc->info.compositeAlpha == VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; + int rgba = sc->info.imageFormat == VK_FORMAT_R8G8B8A8_UNORM || sc->info.imageFormat == VK_FORMAT_R8G8B8A8_SRGB; + if (!sc->copy_present) { + if (!s->dmabuf) { + VKB_INFO("Wayland: the compositor has no zwp_linux_dmabuf_v1"); + return VK_ERROR_FEATURE_NOT_PRESENT; + } + uint32_t fourcc = rgba ? (opaque ? DRM_XBGR8888 : DRM_ABGR8888) : (opaque ? DRM_XRGB8888 : DRM_ARGB8888); + uint64_t mod = sc->images[0].modifier; + if (!dmabuf_supports(s, fourcc, mod)) { + uint32_t alt = rgba ? DRM_ABGR8888 : DRM_ARGB8888; + if (!dmabuf_supports(s, alt, mod)) { + VKB_INFO("Wayland: the compositor takes no %.4s dma-buf with modifier 0x%llx", (char *)&fourcc, (unsigned long long)mod); + return VK_ERROR_FORMAT_NOT_SUPPORTED; + } + fourcc = alt; + } + s->buffers = calloc(sc->count, sizeof(*s->buffers)); + for (uint32_t i = 0; i < sc->count; i++) { + vkb_swap_image *img = &sc->images[i]; + struct wl_proxy *params = wl.proxy_marshal_constructor(s->dmabuf, DMABUF_CREATE_PARAMS, ¶ms_iface, NULL); + wl.proxy_marshal(params, PARAMS_ADD, img->dmabuf_fd, 0u, img->offset, img->stride, (uint32_t)(img->modifier >> 32), + (uint32_t)(img->modifier & 0xffffffffu)); + s->buffers[i] = wl.proxy_marshal_constructor(params, PARAMS_CREATE_IMMED, wl.buffer_iface, NULL, (int32_t)w, (int32_t)h, fourcc, 0u); + wl.proxy_marshal(params, PARAMS_DESTROY); + wl.proxy_destroy(params); + wl.proxy_add_listener(s->buffers[i], (void (**)(void))buffer_listener, img); + } + if (wl.display_roundtrip_queue(s->display, s->queue) < 0 || wl.display_get_error(s->display)) { + VKB_ERR("Wayland: the compositor refused the dma-bufs"); + return VK_ERROR_SURFACE_LOST_KHR; + } + VKB_INFO("Wayland: %u dma-buf buffers %ux%u %.4s, stride %u, modifier 0x%llx", sc->count, w, h, (char *)&fourcc, + sc->images[0].stride, (unsigned long long)sc->images[0].modifier); + return VK_SUCCESS; + } + if (!s->shm) { + VKB_ERR("Wayland: the compositor offers neither dma-buf nor wl_shm"); + return VK_ERROR_SURFACE_LOST_KHR; + } + uint32_t fmt; + if (rgba && has_u32(s->shm_formats, s->nshm, opaque ? DRM_XBGR8888 : DRM_ABGR8888)) { + fmt = opaque ? DRM_XBGR8888 : DRM_ABGR8888; + } else { + fmt = opaque ? WL_SHM_FORMAT_XRGB8888 : WL_SHM_FORMAT_ARGB8888; + s->swizzle = rgba; + } + s->shm_format = fmt; + s->shm_stride = w * 4; + s->nshm_bufs = (int)sc->count + 1; + size_t one = (size_t)s->shm_stride * h; + s->shm_size = one * (size_t)s->nshm_bufs; + int fd = vkb_memfd("vkbridge-wl-shm", s->shm_size); + if (fd < 0) return VK_ERROR_OUT_OF_HOST_MEMORY; + s->shm_map = mmap(NULL, s->shm_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (s->shm_map == MAP_FAILED) { + s->shm_map = NULL; + close(fd); + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + s->shm_pool = wl.proxy_marshal_constructor(s->shm, WL_SHM_CREATE_POOL, wl.shm_pool_iface, NULL, fd, (int32_t)s->shm_size); + close(fd); + s->shm_bufs = calloc((size_t)s->nshm_bufs, sizeof(shm_buf)); + for (int i = 0; i < s->nshm_bufs; i++) { + s->shm_bufs[i].ptr = s->shm_map + one * (size_t)i; + s->shm_bufs[i].buffer = wl.proxy_marshal_constructor(s->shm_pool, WL_SHM_POOL_CREATE_BUFFER, wl.buffer_iface, NULL, + (int32_t)(one * (size_t)i), (int32_t)w, (int32_t)h, (int32_t)s->shm_stride, fmt); + wl.proxy_add_listener(s->shm_bufs[i].buffer, (void (**)(void))shm_buffer_listener, &s->shm_bufs[i]); + } + VKB_INFO("Wayland: presenting %ux%u through wl_shm (format 0x%x%s)", w, h, fmt, s->swizzle ? ", swizzled" : ""); + return VK_SUCCESS; +} + +static void copy_frame(wl_state *s, const uint8_t *src, uint8_t *dst, uint32_t w, uint32_t h) +{ + size_t row = (size_t)w * 4; + if (!s->swizzle) { + memcpy(dst, src, row * h); + return; + } + for (size_t i = 0; i < (size_t)w * h; i++) { + dst[i * 4 + 0] = src[i * 4 + 2]; + dst[i * 4 + 1] = src[i * 4 + 1]; + dst[i * 4 + 2] = src[i * 4 + 0]; + dst[i * 4 + 3] = src[i * 4 + 3]; + } +} + +static VkResult wl_present(vkb_swapchain *sc, uint32_t index, const VkPresentRegionKHR *region) +{ + wl_state *s = sc->bdata; + uint32_t w = sc->info.imageExtent.width, h = sc->info.imageExtent.height; + if (wl.display_get_error(s->display)) return VK_ERROR_SURFACE_LOST_KHR; + /* FIFO: one frame per compositor frame callback (bounded, so a hidden window cannot hang + * the game forever). */ + if (sc->info.presentMode == VK_PRESENT_MODE_FIFO_KHR || sc->info.presentMode == VK_PRESENT_MODE_FIFO_RELAXED_KHR) { + struct timespec t0; + clock_gettime(CLOCK_MONOTONIC, &t0); + while (s->frame) { + if (dispatch_timeout(s, 20000000ull) < 0) return VK_ERROR_SURFACE_LOST_KHR; + struct timespec t1; + clock_gettime(CLOCK_MONOTONIC, &t1); + if ((t1.tv_sec - t0.tv_sec) * 1000 + (t1.tv_nsec - t0.tv_nsec) / 1000000 > 250) break; + } + } + struct wl_proxy *buffer; + if (!sc->copy_present) { + buffer = s->buffers[index]; + } else { + shm_buf *b = NULL; + for (int tries = 0; !b && tries < 50; tries++) { + for (int i = 0; i < s->nshm_bufs; i++) + if (!s->shm_bufs[i].busy) { + b = &s->shm_bufs[i]; + break; + } + if (!b && dispatch_timeout(s, 10000000ull) < 0) return VK_ERROR_SURFACE_LOST_KHR; + } + if (!b) return VK_SUCCESS; /* compositor holds every buffer: drop this frame */ + copy_frame(s, sc->staging_ptr, b->ptr, w, h); + b->busy = 1; + buffer = b->buffer; + } + if (sc->info.presentMode == VK_PRESENT_MODE_FIFO_KHR || sc->info.presentMode == VK_PRESENT_MODE_FIFO_RELAXED_KHR) { + if (s->frame) wl.proxy_destroy(s->frame); + s->frame = wl.proxy_marshal_constructor(s->surface_wrapper, WL_SURFACE_FRAME, wl.callback_iface, NULL); + wl.proxy_add_listener(s->frame, (void (**)(void))frame_listener, s); + } + wl.proxy_marshal(s->surface_wrapper, WL_SURFACE_ATTACH, buffer, 0, 0); + int v4 = wl.proxy_get_version(s->surface_wrapper) >= 4; + if (region && region->rectangleCount && region->pRectangles) { + for (uint32_t i = 0; i < region->rectangleCount; i++) { + const VkRectLayerKHR *r = ®ion->pRectangles[i]; + wl.proxy_marshal(s->surface_wrapper, v4 ? WL_SURFACE_DAMAGE_BUFFER : WL_SURFACE_DAMAGE, r->offset.x, r->offset.y, + (int32_t)r->extent.width, (int32_t)r->extent.height); + } + } else { + wl.proxy_marshal(s->surface_wrapper, v4 ? WL_SURFACE_DAMAGE_BUFFER : WL_SURFACE_DAMAGE, 0, 0, (int32_t)w, (int32_t)h); + } + wl.proxy_marshal(s->surface_wrapper, WL_SURFACE_COMMIT); + wl.display_flush(s->display); + if (wl.display_dispatch_queue_pending(s->display, s->queue) < 0) return VK_ERROR_SURFACE_LOST_KHR; + return VK_SUCCESS; +} + +static VkResult wl_wait_free(vkb_swapchain *sc, uint64_t timeout_ns) +{ + wl_state *s = sc->bdata; + int r = dispatch_timeout(s, timeout_ns); + if (r < 0) return VK_ERROR_SURFACE_LOST_KHR; + return r == 0 ? VK_TIMEOUT : VK_SUCCESS; +} + +static void wl_teardown(wl_state *s) +{ + if (!s) return; + vkb_swapchain *sc = s->sc; + if (s->frame) wl.proxy_destroy(s->frame); + if (s->buffers) { + for (uint32_t i = 0; i < sc->count; i++) + if (s->buffers[i]) { + wl.proxy_marshal(s->buffers[i], WL_BUFFER_DESTROY); + wl.proxy_destroy(s->buffers[i]); + } + free(s->buffers); + } + if (s->shm_bufs) { + for (int i = 0; i < s->nshm_bufs; i++) + if (s->shm_bufs[i].buffer) { + wl.proxy_marshal(s->shm_bufs[i].buffer, WL_BUFFER_DESTROY); + wl.proxy_destroy(s->shm_bufs[i].buffer); + } + free(s->shm_bufs); + } + if (s->shm_pool) { + wl.proxy_marshal(s->shm_pool, WL_SHM_POOL_DESTROY); + wl.proxy_destroy(s->shm_pool); + } + if (s->shm_map) munmap(s->shm_map, s->shm_size); + if (s->dmabuf) { + wl.proxy_marshal(s->dmabuf, DMABUF_DESTROY); + wl.proxy_destroy(s->dmabuf); + } + if (s->shm) wl.proxy_destroy(s->shm); + if (s->registry) wl.proxy_destroy(s->registry); + if (s->surface_wrapper) wl.proxy_wrapper_destroy(s->surface_wrapper); + if (s->display_wrapper) wl.proxy_wrapper_destroy(s->display_wrapper); + if (s->display) wl.display_flush(s->display); + if (s->queue) wl.event_queue_destroy(s->queue); + free(s); +} + +static void wl_destroy(vkb_swapchain *sc) +{ + wl_teardown(sc->bdata); + sc->bdata = NULL; +} + +const vkb_wsi_backend vkb_wsi_wayland_backend = {wl_init, wl_present, wl_wait_free, wl_destroy}; diff --git a/tools/vkbridge/client/wsi_x11.c b/tools/vkbridge/client/wsi_x11.c new file mode 100644 index 000000000..a9cd4222b --- /dev/null +++ b/tools/vkbridge/client/wsi_x11.c @@ -0,0 +1,162 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * X11 presentation, software path: the frame is read back and drawn with PutImage. Used only + * when nothing better exists - under gamescope its WSI layer turns X11 swapchains into Wayland + * ones before they reach this driver. libxcb (and libX11-xcb for Xlib surfaces) is opened at + * run time. + */ +#define _GNU_SOURCE +#include "wsi.h" + +#include +#include +#include + +static struct { + void *lib, *x11xcb; + xcb_get_geometry_cookie_t (*get_geometry)(xcb_connection_t *, xcb_drawable_t); + xcb_get_geometry_reply_t *(*get_geometry_reply)(xcb_connection_t *, xcb_get_geometry_cookie_t, xcb_generic_error_t **); + xcb_void_cookie_t (*put_image)(xcb_connection_t *, uint8_t, xcb_drawable_t, xcb_gcontext_t, uint16_t, uint16_t, int16_t, int16_t, + uint8_t, uint8_t, uint32_t, const uint8_t *); + xcb_void_cookie_t (*create_gc)(xcb_connection_t *, xcb_gcontext_t, xcb_drawable_t, uint32_t, const void *); + xcb_void_cookie_t (*free_gc)(xcb_connection_t *, xcb_gcontext_t); + uint32_t (*generate_id)(xcb_connection_t *); + uint32_t (*get_maximum_request_length)(xcb_connection_t *); + int (*flush)(xcb_connection_t *); + int (*connection_has_error)(xcb_connection_t *); + xcb_connection_t *(*xlib_get_xcb)(void *); +} x; + +int vkb_xcb_load(void) +{ + static int state; + static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; + pthread_mutex_lock(&lock); + if (!state) { + state = -1; + x.lib = dlopen("libxcb.so.1", RTLD_NOW | RTLD_LOCAL); + if (x.lib) { +#define L(f, n) (*(void **)&x.f = dlsym(x.lib, n)) + int ok = 1; + ok &= !!L(get_geometry, "xcb_get_geometry"); + ok &= !!L(get_geometry_reply, "xcb_get_geometry_reply"); + ok &= !!L(put_image, "xcb_put_image"); + ok &= !!L(create_gc, "xcb_create_gc"); + ok &= !!L(free_gc, "xcb_free_gc"); + ok &= !!L(generate_id, "xcb_generate_id"); + ok &= !!L(get_maximum_request_length, "xcb_get_maximum_request_length"); + ok &= !!L(flush, "xcb_flush"); + ok &= !!L(connection_has_error, "xcb_connection_has_error"); +#undef L + if (ok) state = 1; + } + x.x11xcb = dlopen("libX11-xcb.so.1", RTLD_NOW | RTLD_LOCAL); + if (x.x11xcb) *(void **)&x.xlib_get_xcb = dlsym(x.x11xcb, "XGetXCBConnection"); + if (state < 0) VKB_WARN("no usable libxcb: X11 presentation unavailable"); + } + pthread_mutex_unlock(&lock); + return state > 0; +} + +void *vkb_xlib_to_xcb(void *dpy) +{ + if (!vkb_xcb_load() || !x.xlib_get_xcb) return NULL; + return x.xlib_get_xcb(dpy); +} + +static int geometry(vkb_surface *s, uint32_t *w, uint32_t *h, uint8_t *depth) +{ + xcb_get_geometry_reply_t *g = x.get_geometry_reply(s->xcb_conn, x.get_geometry(s->xcb_conn, s->xcb_window), NULL); + if (!g) return 0; + *w = g->width; + *h = g->height; + if (depth) *depth = g->depth; + free(g); + return 1; +} + +VkResult vkb_xcb_surface_extent(vkb_surface *s, VkExtent2D *e) +{ + uint32_t w, h; + if (!geometry(s, &w, &h, NULL)) return VK_ERROR_SURFACE_LOST_KHR; + e->width = w; + e->height = h; + return VK_SUCCESS; +} + +typedef struct x11_state { + xcb_gcontext_t gc; + uint8_t depth; + uint8_t *swz; +} x11_state; + +static VkResult x11_init(vkb_swapchain *sc) +{ + vkb_surface *s = sc->surface; + x11_state *st = calloc(1, sizeof(*st)); + sc->bdata = st; + uint32_t w, h; + if (!geometry(s, &w, &h, &st->depth)) return VK_ERROR_SURFACE_LOST_KHR; + if (st->depth != 24 && st->depth != 32) { + VKB_ERR("X11: window depth %u is not supported by the software present path", st->depth); + return VK_ERROR_SURFACE_LOST_KHR; + } + st->gc = x.generate_id(s->xcb_conn); + x.create_gc(s->xcb_conn, st->gc, s->xcb_window, 0, NULL); + VKB_INFO("X11: presenting %ux%u by PutImage (software path)", sc->info.imageExtent.width, sc->info.imageExtent.height); + return VK_SUCCESS; +} + +static VkResult x11_present(vkb_swapchain *sc, uint32_t index, const VkPresentRegionKHR *region) +{ + (void)index; + (void)region; + vkb_surface *s = sc->surface; + x11_state *st = sc->bdata; + if (x.connection_has_error(s->xcb_conn)) return VK_ERROR_SURFACE_LOST_KHR; + uint32_t w = sc->info.imageExtent.width, h = sc->info.imageExtent.height; + const uint8_t *src = sc->staging_ptr; + int rgba = sc->info.imageFormat == VK_FORMAT_R8G8B8A8_UNORM || sc->info.imageFormat == VK_FORMAT_R8G8B8A8_SRGB; + if (rgba) { + if (!st->swz) st->swz = malloc((size_t)w * h * 4); + for (size_t i = 0; i < (size_t)w * h; i++) { + st->swz[i * 4 + 0] = src[i * 4 + 2]; + st->swz[i * 4 + 1] = src[i * 4 + 1]; + st->swz[i * 4 + 2] = src[i * 4 + 0]; + st->swz[i * 4 + 3] = src[i * 4 + 3]; + } + src = st->swz; + } + /* Split into requests that fit the server's maximum request length (in 4-byte units). */ + size_t max = (size_t)x.get_maximum_request_length(s->xcb_conn) * 4; + size_t row = (size_t)w * 4; + uint32_t rows = max > 64 + row ? (uint32_t)((max - 64) / row) : 1; + for (uint32_t y = 0; y < h; y += rows) { + uint32_t n = h - y < rows ? h - y : rows; + x.put_image(s->xcb_conn, XCB_IMAGE_FORMAT_Z_PIXMAP, s->xcb_window, st->gc, (uint16_t)w, (uint16_t)n, 0, (int16_t)y, 0, st->depth, + (uint32_t)(row * n), src + row * y); + } + x.flush(s->xcb_conn); + uint32_t cw, ch; + if (geometry(s, &cw, &ch, NULL) && (cw != w || ch != h)) sc->status = VK_SUBOPTIMAL_KHR; + return VK_SUCCESS; +} + +static VkResult x11_wait_free(vkb_swapchain *sc, uint64_t timeout_ns) +{ + (void)sc; + (void)timeout_ns; + return VK_TIMEOUT; /* images are free as soon as their present returns */ +} + +static void x11_destroy(vkb_swapchain *sc) +{ + x11_state *st = sc->bdata; + if (!st) return; + if (st->gc) x.free_gc(sc->surface->xcb_conn, st->gc); + free(st->swz); + free(st); + sc->bdata = NULL; +} + +const vkb_wsi_backend vkb_wsi_x11_backend = {x11_init, x11_present, x11_wait_free, x11_destroy}; diff --git a/tools/vkbridge/codegen/gen_vkbridge.py b/tools/vkbridge/codegen/gen_vkbridge.py new file mode 100644 index 000000000..72d78568e --- /dev/null +++ b/tools/vkbridge/codegen/gen_vkbridge.py @@ -0,0 +1,1343 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: GPL-3.0-or-later +""" +Generates the Vulkan bridge's wire code from the pinned Khronos registry (vk.xml 1.3.247). + +Output (into ../common/gen/): + vkb_gen.h command ids, protocol hash, dispatch table, prototypes + vkb_gen_structs.c struct encoders/decoders (both sides; client-only parts under VKB_CLIENT) + vkb_gen_client.c client RPC stubs ("wire" functions) + default entry points + name table + vkb_gen_server.c server handlers + dispatch table loaders + +Wire rules (the C runtime in common/vkb_wire.[ch] implements the primitives): + * A struct is sent as its raw bytes (8-byte aligned in the stream), followed by its "fixups": + every pointer member's pointee, in member order. Non-dispatchable handles are u64 values that + are valid on the server as they are; dispatchable handles are patched to the server's value by + the client. The decoder reads the raw bytes back and replaces every pointer member. + * pNext chains are sent element by element (u32 sType + struct), structs this generator does + not know are skipped (logged once by the runtime), terminated by VKB_CHAIN_END. + * Arrays always carry their element count explicitly; pointers carry a presence byte. + * Output structs travel as a "template" (raw + chain of sType/raw) to the server, which fills + them, and come back as raw + chain; the client copies them into the caller's memory keeping + the caller's own pNext pointers. +""" +import hashlib +import os +import re +import sys +import xml.etree.ElementTree as ET + +HERE = os.path.dirname(os.path.abspath(__file__)) +REG = os.path.join(HERE, '..', 'third_party', 'Vulkan-Headers-1.3.247', 'registry', 'vk.xml') +OUT = os.path.join(HERE, '..', 'common', 'gen') + +# -------------------------------------------------------------------------------------------- +# What is bridged. + +CORE_FEATURES = ['VK_VERSION_1_0', 'VK_VERSION_1_1', 'VK_VERSION_1_2', 'VK_VERSION_1_3'] + +# Extensions whose name contains one of these are never bridged: platform-specific, display +# control, ray tracing, video, or designs that hand raw host pointers/callbacks to the driver. +EXT_BLOCK_SUBSTR = [ + 'video', 'ray_tracing', 'acceleration_structure', 'ray_query', 'win32', 'android', 'fuchsia', + 'metal', '_ggp', 'GGP', 'screen', 'directfb', 'macos', 'ios_', 'MVK', 'NN_', '_vi_', 'display', + 'xlib_xrandr', 'descriptor_buffer', 'shader_object', 'micromap', 'deferred_host_operations', + 'performance_query', 'device_generated_commands', 'mesh_shader', 'device_memory_report', + 'device_address_binding_report', 'pipeline_properties', 'debug_report', 'debug_marker', + 'validation', 'portability', 'direct_driver_loading', 'full_screen_exclusive', + 'pipeline_executable_properties', 'external_memory_host', 'metal_objects', + 'present_wait', 'present_id', 'display_timing', 'shared_presentable_image', + 'swapchain_maintenance1', 'surface_maintenance1', 'hdr_metadata', 'present_barrier', + 'image_compression_control_swapchain', 'surface_protected_capabilities', + 'pipeline_library_group_handles', 'opacity', 'fragment_density_map_offset', + 'external_memory_rdma', 'external_memory_sci', 'external_sci', 'cluster_culling', + 'multiview_per_view', 'shader_enqueue', 'AMDX', 'cuda', 'CUDA', 'QNX', 'optical_flow', + 'low_latency', 'memory_decompression', 'copy_memory_indirect', 'frame_boundary', + 'device_fault', 'descriptor_set_host_mapping', +] +# Structs never sent (callbacks into the app, or meaningless across processes); a pNext chain +# carrying one is sent without it. +STRUCT_BLOCK = {'VkAllocationCallbacks', 'VkDebugUtilsMessengerCreateInfoEXT', + 'VkDebugReportCallbackCreateInfoEXT', 'VkValidationFeaturesEXT', + 'VkValidationFlagsEXT', 'VkLayerSettingsCreateInfoEXT', + 'VkDirectDriverLoadingListLUNARG', 'VkExportMetalObjectCreateInfoEXT'} +EXT_AUTHORS = ('KHR', 'EXT', 'ARM', 'VALVE', 'GOOGLE', 'MESA', 'IMG') +# Implemented by the client itself (no server round trip, or not on the wire at all). +CLIENT_EXTENSIONS = { + 'VK_KHR_surface', 'VK_KHR_swapchain', 'VK_KHR_wayland_surface', 'VK_KHR_xcb_surface', + 'VK_KHR_xlib_surface', 'VK_EXT_headless_surface', 'VK_KHR_get_surface_capabilities2', + 'VK_EXT_swapchain_colorspace', 'VK_KHR_incremental_present', 'VK_EXT_debug_utils', + 'VK_KHR_swapchain_mutable_format', +} +# Extension commands handled entirely client-side (no wire code generated). +LOCAL_COMMANDS_PREFIX = ('vkCreateDebugUtilsMessengerEXT', 'vkDestroyDebugUtilsMessengerEXT', + 'vkSubmitDebugUtilsMessageEXT') + +# Commands whose client entry point is hand-written (the generated wire stub may still be used). +CLIENT_CUSTOM = { + 'vkCreateInstance', 'vkDestroyInstance', 'vkEnumerateInstanceExtensionProperties', + 'vkEnumerateInstanceLayerProperties', 'vkEnumerateInstanceVersion', 'vkGetInstanceProcAddr', + 'vkGetDeviceProcAddr', 'vkEnumeratePhysicalDevices', 'vkEnumeratePhysicalDeviceGroups', + 'vkEnumerateDeviceExtensionProperties', 'vkEnumerateDeviceLayerProperties', + 'vkGetPhysicalDeviceFeatures', 'vkGetPhysicalDeviceFeatures2', + 'vkGetPhysicalDeviceProperties', 'vkGetPhysicalDeviceProperties2', + 'vkGetPhysicalDeviceFormatProperties', 'vkGetPhysicalDeviceFormatProperties2', + 'vkGetPhysicalDeviceImageFormatProperties', 'vkGetPhysicalDeviceImageFormatProperties2', + 'vkGetPhysicalDeviceMemoryProperties', 'vkGetPhysicalDeviceMemoryProperties2', + 'vkGetPhysicalDeviceSparseImageFormatProperties', 'vkGetPhysicalDeviceSparseImageFormatProperties2', + 'vkGetPhysicalDeviceToolProperties', + 'vkCreateDevice', 'vkDestroyDevice', 'vkGetDeviceQueue', 'vkGetDeviceQueue2', + 'vkAllocateCommandBuffers', 'vkFreeCommandBuffers', 'vkDestroyCommandPool', 'vkResetCommandPool', + 'vkBeginCommandBuffer', 'vkEndCommandBuffer', 'vkResetCommandBuffer', + 'vkAllocateMemory', 'vkFreeMemory', 'vkMapMemory', 'vkUnmapMemory', 'vkMapMemory2KHR', + 'vkUnmapMemory2KHR', 'vkFlushMappedMemoryRanges', 'vkInvalidateMappedMemoryRanges', + 'vkGetBufferMemoryRequirements', 'vkGetBufferMemoryRequirements2', + 'vkGetImageMemoryRequirements', 'vkGetImageMemoryRequirements2', + 'vkGetDeviceBufferMemoryRequirements', 'vkGetDeviceImageMemoryRequirements', + 'vkGetMemoryFdPropertiesKHR', 'vkCreateBuffer', 'vkCreateImage', + 'vkCreateDescriptorUpdateTemplate', 'vkDestroyDescriptorUpdateTemplate', + 'vkUpdateDescriptorSetWithTemplate', 'vkCmdPushDescriptorSetWithTemplateKHR', + 'vkCreatePrivateDataSlot', 'vkDestroyPrivateDataSlot', 'vkSetPrivateData', 'vkGetPrivateData', + 'vkQueueSubmit', 'vkQueueSubmit2', 'vkQueueWaitIdle', 'vkDeviceWaitIdle', 'vkWaitForFences', + 'vkGetFenceStatus', 'vkWaitSemaphores', 'vkGetSemaphoreCounterValue', + 'vkGetPhysicalDeviceExternalBufferProperties', 'vkGetPhysicalDeviceQueueFamilyProperties', + 'vkGetPhysicalDeviceQueueFamilyProperties2', 'vkSetDebugUtilsObjectNameEXT', + 'vkSetDebugUtilsObjectTagEXT', 'vkQueueBeginDebugUtilsLabelEXT', 'vkQueueEndDebugUtilsLabelEXT', + 'vkQueueInsertDebugUtilsLabelEXT', 'vkCmdBeginDebugUtilsLabelEXT', 'vkCmdEndDebugUtilsLabelEXT', + 'vkCmdInsertDebugUtilsLabelEXT', 'vkCmdExecuteCommands', 'vkGetImageSubresourceLayout', + 'vkGetPhysicalDeviceMultisamplePropertiesEXT', 'vkGetDeviceImageSparseMemoryRequirements', + 'vkGetImageSparseMemoryRequirements', 'vkGetImageSparseMemoryRequirements2', + 'vkBindBufferMemory', 'vkBindBufferMemory2', 'vkBindImageMemory', 'vkBindImageMemory2', + 'vkDestroyBuffer', 'vkDestroyImage', 'vkGetPhysicalDeviceExternalSemaphoreProperties', + 'vkGetPhysicalDeviceExternalFenceProperties', } +# Commands whose server handler is hand-written (server/*.c defines vkb_sv_). +SERVER_CUSTOM = { + 'vkCreateInstance', 'vkDestroyInstance', 'vkCreateDevice', 'vkDestroyDevice', + 'vkAllocateMemory', 'vkFreeMemory', + 'vkFlushMappedMemoryRanges', 'vkInvalidateMappedMemoryRanges', 'vkEndCommandBuffer', +} + +# File descriptors: (struct, member) and (command, param). +FD_MEMBERS = {('VkImportMemoryFdInfoKHR', 'fd'), ('VkImportSemaphoreFdInfoKHR', 'fd'), + ('VkImportFenceFdInfoKHR', 'fd')} +FD_PARAMS = {('vkGetMemoryFdKHR', 'pFd'), ('vkGetSemaphoreFdKHR', 'pFd'), ('vkGetFenceFdKHR', 'pFd'), + ('vkGetMemoryFdPropertiesKHR', 'fd')} + +# Pointer members whose validity depends on other members (vk.xml "noautovalidity"): +# a C condition (s = the struct) under which the pointer is read. Anything else marked +# noautovalidity is read whenever it is non-NULL. +PTR_CONDITIONS = { + ('VkWriteDescriptorSet', 'pImageInfo'): 'vkb_desc_has_image(s->descriptorType)', + ('VkWriteDescriptorSet', 'pBufferInfo'): 'vkb_desc_has_buffer(s->descriptorType)', + ('VkWriteDescriptorSet', 'pTexelBufferView'): 'vkb_desc_has_texel(s->descriptorType)', + ('VkBufferCreateInfo', 'pQueueFamilyIndices'): 's->sharingMode == VK_SHARING_MODE_CONCURRENT', + ('VkImageCreateInfo', 'pQueueFamilyIndices'): 's->sharingMode == VK_SHARING_MODE_CONCURRENT', + ('VkPhysicalDeviceImageDrmFormatModifierInfoEXT', 'pQueueFamilyIndices'): 's->sharingMode == VK_SHARING_MODE_CONCURRENT', + ('VkDescriptorSetLayoutBinding', 'pImmutableSamplers'): '(s->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || s->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)', + ('VkGraphicsPipelineCreateInfo', 'pTessellationState'): 'vkb_gp_has_tess(s)', + ('VkCommandBufferBeginInfo', 'pInheritanceInfo'): 'vkb_cb_begin_is_secondary(s)', + ('VkFramebufferCreateInfo', 'pAttachments'): '!(s->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)', + ('VkImageCompressionControlEXT', 'pFixedRateFlags'): 's->flags == VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT', +} + +# Lengths written as LaTeX in vk.xml, as C over the struct. +ALTLEN = { + ('VkShaderModuleCreateInfo', 'pCode'): ('bytes', 's->codeSize'), + ('VkPipelineMultisampleStateCreateInfo', 'pSampleMask'): ('count', '(((uint32_t)s->rasterizationSamples + 31) / 32)'), + ('VkAccelerationStructureVersionInfoKHR', 'pVersionData'): ('count', '2 * VK_UUID_SIZE'), + ('vkCmdSetSampleMaskEXT', 'pSampleMask'): ('count', '(((uint32_t)s->samples + 31) / 32)'), +} + +SCALARS = { + 'uint8_t': 1, 'int8_t': 1, 'uint16_t': 2, 'int16_t': 2, 'uint32_t': 4, 'int32_t': 4, + 'uint64_t': 8, 'int64_t': 8, 'float': 4, 'double': 8, 'size_t': 8, 'int': 4, 'char': 1, + 'VkBool32': 4, 'VkDeviceSize': 8, 'VkDeviceAddress': 8, 'VkFlags': 4, 'VkFlags64': 8, + 'VkSampleMask': 4, +} + +# -------------------------------------------------------------------------------------------- + +def api_ok(e): + a = e.get('api') + return a is None or 'vulkan' in a.split(',') + + +class Member: + def __init__(self, el, owner): + self.owner = owner + self.type = el.find('type').text + self.name = el.find('name').text + pre = (el.text or '') + tail = el.find('type').tail or '' + self.const = 'const' in pre + self.ptr = tail.count('*') + ntail = el.find('name').tail or '' + self.fixed = ntail.strip().startswith('[') + self.bitfield = ntail.strip().startswith(':') + self.len = el.get('len') + self.altlen = el.get('altlen') + self.optional = el.get('optional') + self.noauto = el.get('noautovalidity') == 'true' + self.values = el.get('values') + self.decl = ''.join(el.itertext()).strip() + # e.g. "const VkFoo* pBar" - kept for the C prototypes. + self.decl = re.sub(r'\s+', ' ', self.decl) + + +class Registry: + def __init__(self, path): + self.root = ET.parse(path).getroot() + self.types = {} + self.aliases = {} + self.handles = {} + self.structs = {} + self.funcptrs = set() + self.enums = set() + self.bitmasks = {} + self.basetypes = {} + for t in self.root.find('types'): + if t.tag != 'type' or not api_ok(t): + continue + cat = t.get('category') + name = t.get('name') or (t.find('name').text if t.find('name') is not None else None) + if name is None: + continue + if t.get('alias'): + self.aliases[name] = t.get('alias') + continue + self.types[name] = (cat, t) + if cat == 'handle': + self.handles[name] = t.find('type').text == 'VK_DEFINE_HANDLE' + elif cat in ('struct', 'union'): + self.structs[name] = t + elif cat == 'funcpointer': + self.funcptrs.add(name) + elif cat == 'enum': + self.enums.add(name) + elif cat == 'bitmask': + bt = t.find('type').text + self.bitmasks[name] = 8 if bt == 'VkFlags64' else 4 + elif cat == 'basetype': + tt = t.find('type') + self.basetypes[name] = tt.text if tt is not None else None + self.commands = {} + self.cmd_alias = {} + for c in self.root.find('commands'): + if not api_ok(c): + continue + if c.get('alias'): + self.cmd_alias[c.get('name')] = c.get('alias') + continue + proto = c.find('proto') + name = proto.find('name').text + params = [Member(p, name) for p in c.findall('param') if api_ok(p)] + self.commands[name] = {'ret': proto.find('type').text, 'params': params, 'el': c} + self.struct_members = {} + for n, t in self.structs.items(): + self.struct_members[n] = [Member(m, n) for m in t.findall('member') if api_ok(m)] + + def canon(self, name): + while name in self.aliases: + name = self.aliases[name] + return name + + def canon_cmd(self, name): + while name in self.cmd_alias: + name = self.cmd_alias[name] + return name + + +reg = Registry(REG) + +# -------------------------------------------------------------------------------------------- +# Which commands/structs are in. + +included_cmds = set() +cmd_aliases_included = {} # alias name -> canonical +ext_info = {} # ext name -> (type, [commands]) +cmd_origin = {} # canonical cmd -> 'core' or ext name + + +def require_blocks(el): + for req in el.findall('require'): + if not api_ok(req): + continue + yield req + + +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): + 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_aliases_included[c.get('name')] = n + + +def ext_allowed(e): + name = e.get('name') + if 'vulkan' not in (e.get('supported') or '').split(','): + return False + if e.get('platform') and name not in CLIENT_EXTENSIONS: + return False + if not name.startswith('VK_'): + return False + author = name.split('_')[1] + if author not in EXT_AUTHORS: + return False + if name in CLIENT_EXTENSIONS: + return True + for b in EXT_BLOCK_SUBSTR: + if b in name: + return False + return True + + +def dep_blocked(dep): + for name in re.findall(r'VK_[A-Za-z0-9_]+', dep): + if name.startswith('VK_VERSION_'): + continue + author = name.split('_')[1] + if author not in EXT_AUTHORS or any(b in name for b in EXT_BLOCK_SUBSTR): + if name not in CLIENT_EXTENSIONS: + return True + return False + + +bridged_exts = [] +for e in reg.root.find('extensions'): + if not ext_allowed(e): + continue + name = e.get('name') + cmds = [] + for req in require_blocks(e): + dep = req.get('depends') or req.get('feature') or req.get('extension') or '' + # A require block that pulls in a blocked extension's commands is skipped. + if dep_blocked(dep): + continue + for c in req.findall('command'): + cmds.append(c.get('name')) + ext_info[name] = (e.get('type'), cmds) + bridged_exts.append(name) + for cn in cmds: + n = reg.canon_cmd(cn) + included_cmds.add(n) + cmd_origin.setdefault(n, name) + if cn != n: + cmd_aliases_included[cn] = n + +# Every alias of an included command, wherever it was defined. +for a, c in reg.cmd_alias.items(): + cc = reg.canon_cmd(a) + if cc in included_cmds: + cmd_aliases_included[a] = cc + +# WSI / surface commands are client-only: no wire code. +CLIENT_ONLY_EXT = CLIENT_EXTENSIONS +client_only_cmds = set() +for en in CLIENT_ONLY_EXT: + if en in ext_info: + for cn in ext_info[en][1]: + client_only_cmds.add(reg.canon_cmd(cn)) +# The device-group WSI commands from core 1.1 too. +client_only_cmds |= {'vkGetDeviceGroupPresentCapabilitiesKHR', 'vkGetDeviceGroupSurfacePresentModesKHR', + 'vkGetPhysicalDevicePresentRectanglesKHR', 'vkAcquireNextImage2KHR'} +# Local-only (no wire): private data, debug utils. +client_only_cmds |= {'vkCreatePrivateDataSlot', 'vkDestroyPrivateDataSlot', 'vkSetPrivateData', + 'vkGetPrivateData', 'vkSetDebugUtilsObjectNameEXT', 'vkSetDebugUtilsObjectTagEXT', + 'vkQueueBeginDebugUtilsLabelEXT', 'vkQueueEndDebugUtilsLabelEXT', + 'vkQueueInsertDebugUtilsLabelEXT', 'vkCmdBeginDebugUtilsLabelEXT', + 'vkCmdEndDebugUtilsLabelEXT', 'vkCmdInsertDebugUtilsLabelEXT', + 'vkGetInstanceProcAddr', 'vkGetDeviceProcAddr', + 'vkUpdateDescriptorSetWithTemplate', 'vkCmdPushDescriptorSetWithTemplateKHR', + 'vkMapMemory', 'vkUnmapMemory', 'vkMapMemory2KHR', 'vkUnmapMemory2KHR', + 'vkEnumerateDeviceLayerProperties'} + +wire_cmds = sorted(c for c in included_cmds if c not in client_only_cmds) +# Server-only entries in the dispatch table (used by the server itself, never on the wire). +SERVER_DISPATCH_EXTRA = ['vkMapMemory', 'vkUnmapMemory', 'vkGetMemoryHostPointerPropertiesEXT', + 'vkUpdateDescriptorSetWithTemplate', 'vkCmdPushDescriptorSetWithTemplateKHR'] +dispatch_cmds = sorted(set(wire_cmds) | set(SERVER_DISPATCH_EXTRA)) +# Wire-only helpers that are not Vulkan commands (handled by hand on both sides). +EXTRA_WIRE = ['vkbHello', 'vkbQueryServer', 'vkbDescUpdateRaw', 'vkbPushDescRaw'] + +# -------------------------------------------------------------------------------------------- +# Struct closure: every struct reachable from wire commands (params, members, pNext extenders). + +def is_dhandle(t): + t = reg.canon(t) + return reg.handles.get(t) is True + + +def is_ndhandle(t): + t = reg.canon(t) + return reg.handles.get(t) is False + + +def is_struct(t): + return reg.canon(t) in reg.structs + + +def struct_extenders(): + ext = {} + for n, t in reg.structs.items(): + se = t.get('structextends') + if se: + for b in se.split(','): + ext.setdefault(b, []).append(n) + return ext + + +EXTENDERS = struct_extenders() + +# Struct types that may appear in our builds (core or a bridged extension, incl. client ones). +avail_types = set() +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): + for t in req.findall('type'): + avail_types.add(t.get('name')) +for e in reg.root.find('extensions'): + if e.get('name') in ext_info: + for req in require_blocks(e): + dep = req.get('depends') or '' + if dep_blocked(dep): + continue + for t in req.findall('type'): + avail_types.add(t.get('name')) +avail_types = {reg.canon(t) for t in avail_types} | {t for t in avail_types} +# Base types every build has. +avail_types |= {'VkBaseInStructure', 'VkBaseOutStructure'} + +needed_structs = set() + + +def stype_of(sname): + for m in reg.struct_members[sname]: + if m.name == 'sType' and m.values: + return m.values + return None + + +def need_struct(t): + t = reg.canon(t) + if t not in reg.structs or t in needed_structs or t in STRUCT_BLOCK: + return + if t not in avail_types: + return + needed_structs.add(t) + for m in reg.struct_members[t]: + if is_struct(m.type): + need_struct(m.type) + for x in EXTENDERS.get(t, []): + if x in avail_types: + need_struct(x) + + +for c in wire_cmds: + for p in reg.commands[c]['params']: + need_struct(p.type) +# Client WSI structs that the client encodes for nothing - still needed for chain skipping. +for x in list(EXTENDERS): + pass + +problems = [] + + +def check_out_struct(t, seen=None): + t = reg.canon(t) + if t not in reg.structs: + return + seen = seen or set() + if t in seen: + return + seen.add(t) + for m in reg.struct_members[t]: + if m.name != 'pNext' and (m.ptr or is_dhandle(m.type)): + problems.append(f'out struct {t}.{m.name} has a pointer/dispatchable handle') + if is_struct(m.type): + check_out_struct(m.type, seen) + for x in EXTENDERS.get(t, []): + if x in needed_structs: + check_out_struct(x, seen) + +for c in wire_cmds: + for p in reg.commands[c]['params']: + if p.ptr and not p.const and reg.canon(p.type) in reg.structs: + check_out_struct(p.type) + +# -------------------------------------------------------------------------------------------- +# Struct classification. + +pod_cache = {} + + +def is_pod(t): + """No pointer and no dispatchable handle anywhere inside (raw copy is the whole encoding).""" + t = reg.canon(t) + if t in pod_cache: + return pod_cache[t] + if t not in reg.structs: + return True + pod_cache[t] = True + res = True + for m in reg.struct_members[t]: + if m.ptr or is_dhandle(m.type) or m.type in reg.funcptrs or m.bitfield: + res = False + elif is_struct(m.type) and not is_pod(m.type): + res = False + pod_cache[t] = res + return res + + +def has_pnext(t): + return any(m.name == 'pNext' for m in reg.struct_members[reg.canon(t)]) + + +def elem_size_expr(t): + return f'sizeof({t})' + + +def len_expr(owner, m, prefix): + """C expression for element count (or byte count, for void) of member/param m.""" + key = (owner, m.name) + if key in ALTLEN: + kind, expr = ALTLEN[key] + return kind, expr.replace('s->', prefix) + ln = m.len + if ln is None: + return None, None + parts = ln.split(',') + first = parts[0] + if first == 'null-terminated': + return 'string', None + if first.startswith('latexmath'): + problems.append(f'{owner}.{m.name}: latexmath len {ln}') + return None, None + expr = first.replace('->', '->') + # members of the same struct / params of the same command + e = re.sub(r'\b([a-zA-Z_][a-zA-Z0-9_]*)\b', lambda mm: (prefix + mm.group(1)) if mm.group(1)[0].islower() or mm.group(1)[0] == 'p' else mm.group(1), expr, count=1) + if len(parts) > 1 and parts[1] == 'null-terminated': + return 'strarray', e + return 'count', e + + +# -------------------------------------------------------------------------------------------- +# Code emission helpers. + +class W: + def __init__(self): + self.lines = [] + self.ind = 0 + + def __call__(self, s=''): + if s.startswith('}') and self.ind > 0: + self.ind -= 1 + self.lines.append((' ' * self.ind + s) if s else '') + if s.endswith('{'): + self.ind += 1 + elif s.startswith('{') and s.count('{') > s.count('}'): + self.ind += 1 + + def text(self): + return '\n'.join(self.lines) + '\n' + + +HEADER = '/* Generated by tools/vkbridge/codegen/gen_vkbridge.py from vk.xml 1.3.247 - do not edit. */\n' + +# Ordered list of structs (deterministic). +STRUCTS = sorted(needed_structs) +CHAIN_STRUCTS = [s for s in STRUCTS if stype_of(s) and has_pnext(s)] + + +def guard_for(t): + return None + + +# Struct encoders ----------------------------------------------------------------------------- + +sw = W() +sw(HEADER) +sw('#include "vkb_gen.h"') +sw('#include "../vkb_wire.h"') +sw('#include ') +sw() + + +def fixups(sname): + """Members needing work beyond the raw copy.""" + out = [] + for m in reg.struct_members[sname]: + if m.name == 'pNext': + out.append(('pnext', m)) + elif m.bitfield: + problems.append(f'{sname}.{m.name}: bitfield') + elif m.type in reg.funcptrs: + out.append(('funcptr', m)) + elif m.ptr: + out.append(('ptr', m)) + elif is_dhandle(m.type): + out.append(('dhandle', m)) + elif is_struct(m.type) and not is_pod(m.type): + out.append(('embed', m)) + elif (sname, m.name) in FD_MEMBERS: + out.append(('fd', m)) + return out + + +def emit_ptr_enc(w, owner, m, src, prefix, side): + """Encode pointee of pointer member/param m (expression src). side: 'in' only.""" + t = reg.canon(m.type) + cond = PTR_CONDITIONS.get((owner, m.name)) + kind, cnt = len_expr(owner, m, prefix) + guard = f'{src}' + (f' && ({cond.replace("s->", prefix)})' if cond else '') + if m.ptr == 1 and t == 'char' and kind == 'string': + w(f'vkb_enc_str(e, {guard} ? {src} : NULL);') + return + if m.ptr == 2 and t == 'char' and kind == 'strarray': + w(f'vkb_enc_strarray(e, {guard} ? {src} : NULL, {guard} ? (uint32_t)({cnt}) : 0);') + return + if m.ptr == 2: + problems.append(f'{owner}.{m.name}: double pointer') + w(f'vkb_enc_u8(e, 0); /* unsupported double pointer {m.name} */') + return + if t == 'void': + if kind == 'bytes' or (kind == 'count'): + w(f'vkb_enc_blob(e, {guard} ? (const void *){src} : NULL, {guard} ? (size_t)({cnt}) : 0);') + else: + problems.append(f'{owner}.{m.name}: void* without length') + w(f'vkb_enc_u8(e, 0); /* void* {m.name} not sent */') + return + if kind == 'bytes': + w(f'vkb_enc_blob(e, {guard} ? (const void *){src} : NULL, {guard} ? (size_t)({cnt}) : 0);') + return + n = cnt if kind == 'count' else '1' + w(f'if ({guard}) {{') + w(f'uint32_t n_ = (uint32_t)({n});') + w('vkb_enc_u8(e, 1); vkb_enc_u32(e, n_);') + if is_dhandle(t): + w(f'for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_u64(e, vkb_remote((const void *){src}[i_]));') + elif is_struct(t) and not is_pod(t): + w(f'for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_{t}(e, &{src}[i_]);') + else: + w(f'vkb_enc_raw(e, {src}, (size_t)n_ * sizeof(*{src}));') + w('} else {') + w('vkb_enc_u8(e, 0);') + w('}') + + +def emit_ptr_dec(w, owner, m, dst, side): + t = reg.canon(m.type) + kind, cnt = len_expr(owner, m, 's->') + ctype = m.type + if m.ptr == 1 and t == 'char' and kind == 'string': + w(f'{dst} = vkb_dec_str(d);') + return + if m.ptr == 2 and t == 'char' and kind == 'strarray': + w(f'{dst} = vkb_dec_strarray(d);') + return + if m.ptr == 2: + w(f'(void)vkb_dec_u8(d); {dst} = NULL;') + return + if t == 'void' or kind == 'bytes': + if t == 'void' and kind not in ('bytes', 'count'): + w(f'(void)vkb_dec_u8(d); {dst} = NULL;') + else: + w(f'{dst} = ({"const " if m.const else ""}{ctype} *)vkb_dec_blob(d, NULL);') + return + w('if (vkb_dec_u8(d)) {') + w('uint32_t n_ = vkb_dec_u32(d);') + if is_dhandle(t): + w(f'{ctype} *a_ = ({ctype} *)vkb_dec_alloc(d, (size_t)n_ * sizeof({ctype}));') + w(f'for (uint32_t i_ = 0; a_ && i_ < n_; i_++) a_[i_] = ({ctype})(uintptr_t)vkb_dec_u64(d);') + w(f'{dst} = a_;') + elif is_struct(t) and not is_pod(t): + w(f'{ctype} *a_ = ({ctype} *)vkb_dec_alloc(d, (size_t)n_ * sizeof({ctype}));') + w(f'for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_{t}(d, &a_[i_]);') + w(f'{dst} = a_;') + else: + w(f'{dst} = ({"const " if m.const else ""}{ctype} *)vkb_dec_raw_view(d, (size_t)n_ * sizeof({ctype}));') + w('} else {') + w(f'{dst} = NULL;') + w('}') + + +# Prototypes for all non-POD structs. +proto = W() +for s in STRUCTS: + if is_pod(s): + continue + proto(f'void vkb_enc_{s}(vkb_enc *e, const {s} *s);') + proto(f'void vkb_encfix_{s}(vkb_enc *e, const {s} *s, size_t raw);') + proto(f'void vkb_dec_{s}(vkb_dec *d, {s} *s);') + proto(f'void vkb_decfix_{s}(vkb_dec *d, {s} *s);') + +for s in STRUCTS: + if is_pod(s): + continue + fx = fixups(s) + # encode + sw(f'void vkb_encfix_{s}(vkb_enc *e, const {s} *s, size_t raw)') + sw('{') + sw('(void)e; (void)s; (void)raw;') + for kind, m in fx: + if kind == 'pnext': + sw('vkb_enc_chain(e, s->pNext);') + elif kind == 'funcptr': + sw(f'/* {m.name}: function pointer, never sent */') + elif kind == 'dhandle': + if m.fixed: + sw(f'for (size_t i_ = 0; i_ < sizeof(s->{m.name}) / sizeof(s->{m.name}[0]); i_++) vkb_enc_patch_u64(e, raw + offsetof({s}, {m.name}) + i_ * 8, vkb_remote((const void *)s->{m.name}[i_]));') + else: + sw(f'vkb_enc_patch_u64(e, raw + offsetof({s}, {m.name}), vkb_remote((const void *)s->{m.name}));') + elif kind == 'embed': + mt = reg.canon(m.type) + if m.fixed: + sw(f'for (size_t i_ = 0; i_ < sizeof(s->{m.name}) / sizeof(s->{m.name}[0]); i_++) vkb_encfix_{mt}(e, &s->{m.name}[i_], raw + offsetof({s}, {m.name}) + i_ * sizeof({mt}));') + else: + sw(f'vkb_encfix_{mt}(e, &s->{m.name}, raw + offsetof({s}, {m.name}));') + elif kind == 'fd': + sw(f'vkb_enc_fd(e, s->{m.name});') + elif kind == 'ptr': + if m.noauto and (s, m.name) not in PTR_CONDITIONS and m.len is None and not m.optional: + pass + emit_ptr_enc(sw, s, m, f's->{m.name}', 's->', 'in') + sw('}') + sw() + sw(f'void vkb_enc_{s}(vkb_enc *e, const {s} *s)') + sw('{') + sw(f'size_t raw = vkb_enc_raw(e, s, sizeof(*s));') + sw(f'vkb_encfix_{s}(e, s, raw);') + sw('}') + sw() + # decode + sw(f'void vkb_decfix_{s}(vkb_dec *d, {s} *s)') + sw('{') + sw('(void)d; (void)s;') + for kind, m in fx: + if kind == 'pnext': + sw('s->pNext = (void *)vkb_dec_chain(d);') + elif kind == 'funcptr': + sw(f's->{m.name} = NULL;') + elif kind == 'embed': + mt = reg.canon(m.type) + if m.fixed: + sw(f'for (size_t i_ = 0; i_ < sizeof(s->{m.name}) / sizeof(s->{m.name}[0]); i_++) vkb_decfix_{mt}(d, &s->{m.name}[i_]);') + else: + sw(f'vkb_decfix_{mt}(d, &s->{m.name});') + elif kind == 'fd': + sw(f's->{m.name} = vkb_dec_fd(d);') + elif kind == 'ptr': + emit_ptr_dec(sw, s, m, f's->{m.name}', 'in') + sw('}') + sw() + sw(f'void vkb_dec_{s}(vkb_dec *d, {s} *s)') + sw('{') + sw('vkb_dec_raw_into(d, s, sizeof(*s));') + sw(f'vkb_decfix_{s}(d, s);') + sw('}') + sw() + +# Chain dispatch. +sw('size_t vkb_struct_size(VkStructureType t)') +sw('{') +sw('switch ((int)t) {') +for s in CHAIN_STRUCTS: + sw(f'case {stype_of(s)}: return sizeof({s});') +sw('default: return 0;') +sw('}') +sw('}') +sw() +sw('void vkb_enc_chain_elem(vkb_enc *e, const VkBaseInStructure *b)') +sw('{') +sw('switch ((int)b->sType) {') +for s in CHAIN_STRUCTS: + if is_pod(s): + continue + sw(f'case {stype_of(s)}: vkb_enc_{s}(e, (const {s} *)b); return;') +sw('default: vkb_enc_raw(e, b, vkb_struct_size(b->sType)); return;') +sw('}') +sw('}') +sw() +sw('void vkb_dec_chain_elem(vkb_dec *d, VkStructureType t, void *dst)') +sw('{') +sw('switch ((int)t) {') +for s in CHAIN_STRUCTS: + if is_pod(s): + continue + sw(f'case {stype_of(s)}: vkb_dec_{s}(d, ({s} *)dst); return;') +sw('default: vkb_dec_raw_into(d, dst, vkb_struct_size(t)); return;') +sw('}') +sw('}') +sw() + +# Dispatchable-handle out conversion helpers are in the runtime; nothing else per struct. + +# -------------------------------------------------------------------------------------------- +# Commands. + +def cmd_level(c): + ps = reg.commands[c]['params'] + if not ps or not is_dhandle(ps[0].type): + return 'global' + t = reg.canon(ps[0].type) + if t in ('VkInstance', 'VkPhysicalDevice'): + return 'instance' + return 'device' + + +def objtype(t): + t = reg.canon(t) + return { + 'VkInstance': 'VK_OBJECT_TYPE_INSTANCE', 'VkPhysicalDevice': 'VK_OBJECT_TYPE_PHYSICAL_DEVICE', + 'VkDevice': 'VK_OBJECT_TYPE_DEVICE', 'VkQueue': 'VK_OBJECT_TYPE_QUEUE', + 'VkCommandBuffer': 'VK_OBJECT_TYPE_COMMAND_BUFFER', + }[t] + + +def param_class(c, p): + """in-value | in-ptr | out-ptr | inout-scalar | skip""" + t = reg.canon(p.type) + if t == 'VkAllocationCallbacks': + return 'skip' + if p.ptr == 0: + if p.fixed: + return 'in-fixed' + return 'in-value' + if p.const: + return 'in-ptr' + return 'out-ptr' + + +def scalar_size(t): + t = reg.canon(t) + if t in SCALARS: + return SCALARS[t] + if t in reg.enums: + return 4 + if t in reg.bitmasks: + return reg.bitmasks[t] + if t in reg.handles: + return 8 + if t in reg.basetypes: + bt = reg.basetypes[t] + if bt in SCALARS: + return SCALARS[bt] + return None + + +cw = W() # client +vw = W() # server +hw = W() # header + +cmd_ids = EXTRA_WIRE + wire_cmds +proto_hash = hashlib.sha256(('\n'.join(cmd_ids) + '\n'.join(STRUCTS)).encode()).hexdigest()[:16] + +hw('/* Generated by tools/vkbridge/codegen/gen_vkbridge.py from vk.xml 1.3.247 - do not edit. */') +hw('#ifndef VKB_GEN_H') +hw('#define VKB_GEN_H') +hw('#define VK_NO_PROTOTYPES 1') +hw('#ifdef VKB_CLIENT') +hw('#define VK_USE_PLATFORM_WAYLAND_KHR 1') +hw('#define VK_USE_PLATFORM_XCB_KHR 1') +hw('#define VK_USE_PLATFORM_XLIB_KHR 1') +hw('#endif') +hw('#include ') +hw('#include ') +hw('#include ') +hw('typedef struct vkb_enc vkb_enc;') +hw('typedef struct vkb_dec vkb_dec;') +hw(f'#define VKB_PROTOCOL_HASH 0x{proto_hash}ULL') +hw('enum vkb_cmd_id {') +for i, c in enumerate(cmd_ids): + hw(f'VKB_CMD_{c} = {i},') +hw(f'VKB_CMD_COUNT = {len(cmd_ids)}') +hw('};') +hw('extern const char *const vkb_cmd_names[VKB_CMD_COUNT];') +hw() +hw('/* Every bridged command, by its canonical name (aliases resolve to these). */') +hw('typedef struct vkb_dispatch {') +for c in dispatch_cmds: + hw(f'PFN_{c} {c};') +hw('} vkb_dispatch;') +hw('void vkb_dispatch_load_instance(vkb_dispatch *dt, PFN_vkGetInstanceProcAddr gipa, VkInstance instance);') +hw('void vkb_dispatch_load_device(vkb_dispatch *dt, PFN_vkGetDeviceProcAddr gdpa, VkDevice device);') +hw() +hw('size_t vkb_struct_size(VkStructureType t);') +hw('void vkb_enc_chain_elem(vkb_enc *e, const VkBaseInStructure *b);') +hw('void vkb_dec_chain_elem(vkb_dec *d, VkStructureType t, void *dst);') +for l in proto.lines: + hw(l) +hw() +hw('/* Bridged extensions: name, 1 = device, client-implemented flag. */') +hw('typedef struct vkb_ext_desc { const char *name; uint8_t device; uint8_t client; } vkb_ext_desc;') +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('#define VKB_LEVEL_GLOBAL 0') +hw('#define VKB_LEVEL_INSTANCE 1') +hw('#define VKB_LEVEL_PHYSDEV 2') +hw('#define VKB_LEVEL_DEVICE 3') +hw('extern const vkb_proc_desc vkb_client_procs[];') +hw('extern const size_t vkb_client_proc_count;') +hw() + +# Name table and extension table. +names = W() +names('const char *const vkb_cmd_names[VKB_CMD_COUNT] = {') +for c in cmd_ids: + names(f'"{c}",') +names('};') +names('const vkb_ext_desc vkb_exts[VKB_EXT_COUNT] = {') +for e in bridged_exts: + names(f'{{"{e}", {1 if ext_info[e][0] == "device" else 0}, {1 if e in CLIENT_EXTENSIONS else 0}}},') +names('};') +for l in names.lines: + sw(l) + +# Server dispatch loaders. +vw(HEADER) +vw('#include "vkb_gen.h"') +vw('#include "../vkb_wire.h"') +vw('#include "vkb_server_gen.h"') +vw('#include "../vkb_server_iface.h"') +vw('#include ') +vw() + +aliases_of = {} +for a, c in cmd_aliases_included.items(): + aliases_of.setdefault(c, []).append(a) + +vw('void vkb_dispatch_load_instance(vkb_dispatch *dt, PFN_vkGetInstanceProcAddr gipa, VkInstance instance)') +vw('{') +for c in dispatch_cmds: + vw(f'dt->{c} = (PFN_{c})gipa(instance, "{c}");') + for a in sorted(aliases_of.get(c, [])): + vw(f'if (!dt->{c}) dt->{c} = (PFN_{c})gipa(instance, "{a}");') +vw('}') +vw() +vw('void vkb_dispatch_load_device(vkb_dispatch *dt, PFN_vkGetDeviceProcAddr gdpa, VkDevice device)') +vw('{') +for c in dispatch_cmds: + if cmd_level(c) != 'device': + continue + vw('{') + 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_;') + vw('}') +vw('}') +vw() + +# Server header (custom handlers' prototypes). +svh = W() +svh(HEADER) +svh('#ifndef VKB_SERVER_GEN_H') +svh('#define VKB_SERVER_GEN_H') +svh('#include "vkb_gen.h"') +svh('typedef struct vkb_srv_call vkb_srv_call;') +svh('typedef void (*vkb_srv_handler)(vkb_srv_call *c);') +svh('extern const vkb_srv_handler vkb_srv_handlers[VKB_CMD_COUNT];') +for c in wire_cmds: + svh(f'void vkb_sv_{c}(vkb_srv_call *c);') +for c in EXTRA_WIRE: + svh(f'void vkb_sv_{c}(vkb_srv_call *c);') +svh('#endif') + +# Client header. +clh = W() +clh(HEADER) +clh('#ifndef VKB_CLIENT_GEN_H') +clh('#define VKB_CLIENT_GEN_H') +clh('#include "vkb_gen.h"') + +cw(HEADER) +cw('#include "vkb_gen.h"') +cw('#include "vkb_client_gen.h"') +cw('#include "../vkb_wire.h"') +cw('#include "../../client/vkb_client.h"') +cw('#include ') +cw() + + +def c_param_decl(p): + return p.decl + + +def is_out_struct_templ(t): + t = reg.canon(t) + return is_struct(t) and has_pnext(t) + + +for c in wire_cmds: + cmd = reg.commands[c] + ret = cmd['ret'] + params = cmd['params'] + level = cmd_level(c) + is_cmdbuf = c.startswith('vkCmd') + decl = ', '.join(c_param_decl(p) for p in params) + wire_name = f'vkb_wire_{c}' + ret_c = ret + clh(f'{ret_c} {wire_name}({decl});') + + # ---------------- client wire stub + cw(f'{ret_c} {wire_name}({decl})') + cw('{') + first = params[0].name if params and is_dhandle(params[0].type) else None + if is_cmdbuf: + cw(f'vkb_enc *e = vkb_cmd_record_begin({first}, VKB_CMD_{c});') + cw('if (!e) return;') + else: + tbl = f'vkb_table_of((const void *){first})' if first else '0' + cw('vkb_call call_;') + cw(f'vkb_call_begin(&call_, VKB_CMD_{c}, {tbl});') + cw('vkb_enc *e = &call_.e;') + outs = [] + for p in params: + pc = param_class(c, p) + t = reg.canon(p.type) + if pc == 'skip': + cw(f'(void){p.name};') + continue + if (c, p.name) in FD_PARAMS: + if pc == 'in-value': + cw(f'vkb_enc_fd(e, {p.name});') + else: + cw(f'vkb_enc_u8(e, {p.name} != NULL);') + outs.append(('fd', p)) + continue + if pc == 'in-value': + if is_dhandle(t): + cw(f'vkb_enc_u64(e, vkb_remote((const void *){p.name}));') + elif is_struct(t): + if is_pod(t): + cw(f'vkb_enc_raw(e, &{p.name}, sizeof({p.name}));') + else: + cw(f'vkb_enc_{t}(e, &{p.name});') + else: + sz = scalar_size(t) + if sz is None: + problems.append(f'{c}.{p.name}: unknown scalar {t}') + sz = 8 + cw(f'vkb_enc_bytes(e, &{p.name}, sizeof({p.name}));') + elif pc == 'in-fixed': + cw(f'vkb_enc_raw(e, {p.name}, sizeof({p.type}) * {re.search(r"\[(.*)\]", p.decl).group(1)});') + elif pc == 'in-ptr': + emit_ptr_enc(cw, c, p, p.name, '', 'in') + elif pc == 'out-ptr': + kind, cnt = len_expr(c, p, '') + if t == 'void' and p.ptr == 2: + problems.append(f'{c}.{p.name}: void** out') + cw(f'vkb_enc_u8(e, 0);') + continue + if t == 'void': + # Out bytes: length is a size param (value) or a size_t* (two-call). + if kind == 'count' and cnt and not cnt.startswith('p'): + cw(f'vkb_enc_u8(e, {p.name} != NULL); vkb_enc_u64(e, (uint64_t)({cnt}));') + outs.append(('bytes', p, cnt)) + elif kind == 'count': + cw(f'vkb_enc_u8(e, {p.name} != NULL); vkb_enc_u64(e, {p.name} ? (uint64_t)*{cnt} : 0);') + outs.append(('bytes2', p, cnt)) + else: + problems.append(f'{c}.{p.name}: void* out without len') + cw('vkb_enc_u8(e, 0);') + continue + if kind == 'count': + twocall = cnt.startswith('p') and '->' not in cnt + n = f'*{cnt}' if twocall else cnt + cw(f'{{ uint32_t n_ = {p.name} ? (uint32_t)({n if not twocall else f"({cnt} ? {n} : 0)"}) : 0;') + cw(f'vkb_enc_u8(e, {p.name} != NULL); vkb_enc_u32(e, n_);') + if is_out_struct_templ(t): + cw(f'for (uint32_t i_ = 0; {p.name} && i_ < n_; i_++) vkb_enc_out_template(e, &{p.name}[i_], sizeof({t}));') + cw('}') + outs.append(('array', p, cnt, twocall)) + else: + # single out (scalar, handle, struct), or in/out scalar (counts) + cw(f'vkb_enc_u8(e, {p.name} != NULL);') + if is_out_struct_templ(t): + cw(f'if ({p.name}) vkb_enc_out_template(e, {p.name}, sizeof({t}));') + elif not is_struct(t) and not is_dhandle(t): + cw(f'if ({p.name}) vkb_enc_bytes(e, {p.name}, sizeof(*{p.name}));') + outs.append(('single', p)) + if is_cmdbuf: + cw(f'vkb_cmd_record_end({first});') + cw('}') + cw() + else: + cw('if (!vkb_call_exec(&call_)) {') + if ret == 'VkResult': + cw('return VK_ERROR_DEVICE_LOST;') + elif ret == 'void': + cw('return;') + else: + cw(f'return ({ret})0;') + cw('}') + cw('vkb_dec *d = &call_.d;') + cw('(void)d;') + if ret != 'void': + cw(f'{ret} r_;') + cw('vkb_dec_bytes(d, &r_, sizeof(r_));') + for o in outs: + p = o[1] + t = reg.canon(p.type) + if o[0] == 'fd': + cw(f'{{ int fd_ = vkb_dec_fd(d); if ({p.name}) *{p.name} = fd_; else if (fd_ >= 0) vkb_close_fd(fd_); }}') + elif o[0] == 'bytes': + cw(f'vkb_dec_blob_into(d, {p.name}, (size_t)({o[2]}));') + elif o[0] == 'bytes2': + cw(f'{{ uint64_t sz_ = vkb_dec_u64(d); if ({o[2]}) {{ size_t cap_ = {p.name} ? *{o[2]} : 0; *{o[2]} = (size_t)sz_; vkb_dec_blob_into(d, {p.name}, cap_); }} else vkb_dec_blob_into(d, NULL, 0); }}') + elif o[0] == 'array': + cnt, twocall = o[2], o[3] + cw('{') + cw('uint32_t rn_ = vkb_dec_u32(d);') + cw('(void)rn_;') + if twocall: + cw(f'uint32_t cap_ = ({p.name} && {cnt}) ? *{cnt} : 0;') + cw(f'if ({cnt}) *{cnt} = rn_;') + else: + cw(f'uint32_t cap_ = {p.name} ? (uint32_t)({cnt}) : 0;') + cw('uint32_t has_ = vkb_dec_u32(d);') + cw('for (uint32_t i_ = 0; i_ < has_; i_++) {') + cw('if (i_ >= cap_) { d->err = 1; break; }') + if is_dhandle(t): + cw(f'{p.name}[i_] = ({p.type})vkb_wrap({objtype(t)}, (const void *){first or 'NULL'}, vkb_dec_u64(d));') + elif is_out_struct_templ(t): + cw(f'vkb_dec_out_struct(d, &{p.name}[i_], sizeof({t}));') + else: + cw(f'vkb_dec_raw_into(d, &{p.name}[i_], sizeof({t}));') + cw('}') + cw('}') + elif o[0] == 'single': + cw(f'if (vkb_dec_u8(d)) {{') + if is_dhandle(t): + cw(f'{p.type} h_ = ({p.type})vkb_wrap({objtype(t)}, (const void *){first or 'NULL'}, vkb_dec_u64(d));') + cw(f'if ({p.name}) *{p.name} = h_;') + elif is_out_struct_templ(t): + cw(f'if ({p.name}) vkb_dec_out_struct(d, {p.name}, sizeof({t})); else d->err = 1;') + else: + cw(f'if ({p.name}) vkb_dec_raw_into(d, {p.name}, sizeof(*{p.name})); else d->err = 1;') + cw('}') + cw('vkb_call_end(&call_);') + if ret != 'void': + cw('return r_;') + cw('}') + cw() + + # ---------------- server handler + if c in SERVER_CUSTOM: + continue + vw(f'void vkb_sv_{c}(vkb_srv_call *c)') + vw('{') + vw('vkb_dec *d = &c->d;') + vw('vkb_enc *e = &c->r;') + vw('(void)e;') + call_args = [] + post = [] + for p in params: + pc = param_class(c, p) + t = reg.canon(p.type) + if pc == 'skip': + call_args.append('NULL') + continue + if (c, p.name) in FD_PARAMS: + if pc == 'in-value': + vw(f'int {p.name} = vkb_dec_fd(d);') + post.append(f'if ({p.name} >= 0) vkb_close_fd({p.name});') + call_args.append(p.name) + else: + vw(f'int {p.name}_v = -1; int *{p.name} = vkb_dec_u8(d) ? &{p.name}_v : NULL;') + call_args.append(p.name) + continue + if pc == 'in-value': + if is_dhandle(t): + vw(f'{p.type} {p.name} = ({p.type})(uintptr_t)vkb_dec_u64(d);') + elif is_struct(t): + vw(f'{p.type} {p.name};') + if is_pod(t): + vw(f'vkb_dec_raw_into(d, &{p.name}, sizeof({p.name}));') + else: + vw(f'vkb_dec_{t}(d, &{p.name});') + else: + vw(f'{p.type} {p.name};') + vw(f'vkb_dec_bytes(d, &{p.name}, sizeof({p.name}));') + call_args.append(p.name) + elif pc == 'in-fixed': + dim = re.search(r"\[(.*)\]", p.decl).group(1) + vw(f'const {p.type} *{p.name} = (const {p.type} *)vkb_dec_raw_view(d, sizeof({p.type}) * {dim});') + call_args.append(p.name) + elif pc == 'in-ptr': + vw(f'const {p.type} {"*" * p.ptr}{p.name};') + if p.ptr == 2 and t == 'char': + emit_ptr_dec(vw, c, p, p.name, 'in') + else: + # emit_ptr_dec writes with "s->" names for struct contexts; params use bare names. + tmp = W() + emit_ptr_dec(tmp, c, p, p.name, 'in') + for l in tmp.lines: + vw(l.strip()) + call_args.append(f'({p.decl.rsplit(" ", 1)[0]}){p.name}' if p.ptr == 2 else p.name) + elif pc == 'out-ptr': + kind, cnt = len_expr(c, p, '') + if t == 'void': + if kind == 'count' and cnt and not cnt.startswith('p'): + vw(f'uint8_t has_{p.name} = vkb_dec_u8(d); uint64_t n_{p.name} = vkb_dec_u64(d);') + vw(f'void *{p.name} = has_{p.name} ? vkb_dec_alloc(d, (size_t)n_{p.name}) : NULL;') + post.append(f'vkb_enc_blob(e, {p.name}, (size_t)n_{p.name});') + elif kind == 'count': + vw(f'uint8_t has_{p.name} = vkb_dec_u8(d); uint64_t n_{p.name} = vkb_dec_u64(d);') + vw(f'void *{p.name} = has_{p.name} ? vkb_dec_alloc(d, (size_t)n_{p.name}) : NULL;') + # the size param is handled as an in/out scalar (size_t*); patch it to our cap + post.append(f'vkb_enc_u64(e, {cnt} ? (uint64_t)*{cnt} : 0); vkb_enc_blob(e, {p.name}, {p.name} && {cnt} ? (size_t)*{cnt} : 0);') + vw(f'if ({cnt} && {p.name}) *{cnt} = (size_t)n_{p.name};') + call_args.append(p.name) + continue + if kind == 'count': + twocall = cnt.startswith('p') and '->' not in cnt + vw(f'uint8_t has_{p.name} = vkb_dec_u8(d); uint32_t n_{p.name} = vkb_dec_u32(d);') + vw(f'{p.type} *{p.name} = has_{p.name} ? ({p.type} *)vkb_dec_alloc_zero(d, (size_t)n_{p.name} * sizeof({p.type})) : NULL;') + if is_out_struct_templ(t): + vw(f'for (uint32_t i_ = 0; {p.name} && i_ < n_{p.name}; i_++) vkb_dec_out_template(d, &{p.name}[i_], sizeof({t}));') + if twocall: + vw(f'if ({p.name} && {cnt}) *{cnt} = n_{p.name};') + rn = f'({cnt} ? *{cnt} : 0)' + else: + rn = f'n_{p.name}' + post.append('{') + post.append(f'uint32_t rn_ = {rn};') + post.append(f'uint32_t has_ = {p.name} ? (rn_ < n_{p.name} ? rn_ : n_{p.name}) : 0;') + post.append('vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_);') + if is_dhandle(t): + post.append(f'for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_u64(e, (uint64_t)(uintptr_t){p.name}[i_]);') + elif is_out_struct_templ(t): + post.append(f'for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_out_struct(e, &{p.name}[i_], sizeof({t}));') + else: + post.append(f'for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &{p.name}[i_], sizeof({t}));') + post.append('}') + else: + vw(f'uint8_t has_{p.name} = vkb_dec_u8(d);') + vw(f'{p.type} {p.name}_v;') + vw(f'memset(&{p.name}_v, 0, sizeof({p.name}_v));') + if is_out_struct_templ(t): + vw(f'if (has_{p.name}) vkb_dec_out_template(d, &{p.name}_v, sizeof({t}));') + elif not is_struct(t) and not is_dhandle(t): + vw(f'if (has_{p.name}) vkb_dec_bytes(d, &{p.name}_v, sizeof({p.name}_v));') + vw(f'{p.type} *{p.name} = has_{p.name} ? &{p.name}_v : NULL;') + post.append(f'vkb_enc_u8(e, {p.name} != NULL);') + if is_dhandle(t): + post.append(f'if ({p.name}) vkb_enc_u64(e, (uint64_t)(uintptr_t)*{p.name});') + elif is_out_struct_templ(t): + post.append(f'if ({p.name}) vkb_enc_out_struct(e, {p.name}, sizeof({t}));') + else: + post.append(f'if ({p.name}) vkb_enc_raw(e, {p.name}, sizeof(*{p.name}));') + call_args.append(p.name) + vw('if (d->err) { vkb_srv_bad_message(c); return; }') + fn = f'c->dt->{c}' + vw(f'if (!{fn}) {{ vkb_srv_missing(c, "{c}"); return; }}') + if ret != 'void': + vw(f'{ret} r_ = {fn}({", ".join(call_args)});') + vw('vkb_enc_bytes(e, &r_, sizeof(r_));') + else: + vw(f'{fn}({", ".join(call_args)});') + # fds out after result + for p in params: + if (c, p.name) in FD_PARAMS and param_class(c, p) == 'out-ptr': + vw(f'vkb_enc_fd(e, {p.name} ? *{p.name} : -1);') + vw(f'if ({p.name} && *{p.name} >= 0) vkb_srv_close_after_send(c, *{p.name});') + for l in post: + vw(l) + vw('}') + vw() + +# Handler table. +vw('const vkb_srv_handler vkb_srv_handlers[VKB_CMD_COUNT] = {') +for c in cmd_ids: + vw(f'[VKB_CMD_{c}] = vkb_sv_{c},') +vw('};') + +# Client default entry points: everything not custom forwards to its wire stub. +cw('/* Default entry points. */') +for c in wire_cmds: + if c in CLIENT_CUSTOM: + continue + cmd = reg.commands[c] + params = cmd['params'] + decl = ', '.join(c_param_decl(p) for p in params) + args = ', '.join(p.name for p in params) + ret = cmd['ret'] + cw(f'static VKAPI_ATTR {ret} VKAPI_CALL vkb_ep_{c}({decl})') + cw('{') + cw(f'{"return " if ret != "void" else ""}vkb_wire_{c}({args});') + cw('}') + cw() + +# Prototypes of hand-written entry points (client/*.c define them). +for c in sorted(included_cmds): + if c in CLIENT_CUSTOM or c in client_only_cmds: + cmd = reg.commands[c] + decl = ', '.join(c_param_decl(p) for p in cmd['params']) + clh(f'VKAPI_ATTR {cmd["ret"]} VKAPI_CALL vkb_ep_{c}({decl});') +clh('#endif') + + +def level_of(c): + lv = cmd_level(c) + if lv == 'global': + return 'VKB_LEVEL_GLOBAL' + if lv == 'instance': + t = reg.canon(reg.commands[c]['params'][0].type) + return 'VKB_LEVEL_PHYSDEV' if t == 'VkPhysicalDevice' else 'VKB_LEVEL_INSTANCE' + return 'VKB_LEVEL_DEVICE' + + +cw('const vkb_proc_desc vkb_client_procs[] = {') +entries = [] +for c in sorted(included_cmds): + origin = cmd_origin.get(c, 'core') + entries.append((c, c, origin)) +for a, c in sorted(cmd_aliases_included.items()): + entries.append((a, c, None)) +for name, c, origin in sorted(entries): + ext = 'NULL' + # aliases come from the extension that introduced them; find by registry lookup + o = cmd_origin.get(c, 'core') if name == c else None + if name != c: + # find the extension listing this alias name + for en, (_, cl) in ext_info.items(): + if name in cl: + o = en + break + 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}}},') +cw('};') +cw('const size_t vkb_client_proc_count = sizeof(vkb_client_procs) / sizeof(vkb_client_procs[0]);') + +hw('#endif') + +os.makedirs(OUT, exist_ok=True) +files = { + 'vkb_gen.h': hw.text(), + 'vkb_gen_structs.c': sw.text(), + 'vkb_gen_client.c': cw.text(), + 'vkb_client_gen.h': clh.text(), + 'vkb_gen_server.c': vw.text(), + 'vkb_server_gen.h': svh.text(), +} +for n, txt in files.items(): + with open(os.path.join(OUT, n), 'w') as f: + f.write(txt) + +print(f'commands: {len(included_cmds)} bridged, {len(wire_cmds)} on the wire, ' + f'{len(client_only_cmds & included_cmds)} client-only; structs: {len(STRUCTS)} ' + f'({sum(1 for s in STRUCTS if not is_pod(s))} non-POD); extensions: {len(bridged_exts)}; ' + f'protocol {proto_hash}') +if problems: + print('\n'.join(sorted(set(problems))), file=sys.stderr) diff --git a/tools/vkbridge/common/gen/vkb_client_gen.h b/tools/vkbridge/common/gen/vkb_client_gen.h new file mode 100644 index 000000000..6ac7ce4d7 --- /dev/null +++ b/tools/vkbridge/common/gen/vkb_client_gen.h @@ -0,0 +1,397 @@ +/* Generated by tools/vkbridge/codegen/gen_vkbridge.py from vk.xml 1.3.247 - do not edit. */ + +#ifndef VKB_CLIENT_GEN_H +#define VKB_CLIENT_GEN_H +#include "vkb_gen.h" +VkResult vkb_wire_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +VkResult vkb_wire_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); +VkResult vkb_wire_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); +VkResult vkb_wire_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +VkResult vkb_wire_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +VkResult vkb_wire_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +VkResult vkb_wire_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +VkResult vkb_wire_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +void vkb_wire_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); +void vkb_wire_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +void vkb_wire_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); +void vkb_wire_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +void vkb_wire_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +void vkb_wire_vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +void vkb_wire_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +void vkb_wire_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +void vkb_wire_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +void vkb_wire_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +void vkb_wire_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); +void vkb_wire_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +void vkb_wire_vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +void vkb_wire_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); +void vkb_wire_vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +void vkb_wire_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); +void vkb_wire_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +void vkb_wire_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +void vkb_wire_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +void vkb_wire_vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +void vkb_wire_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +void vkb_wire_vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +void vkb_wire_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +void vkb_wire_vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +void vkb_wire_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +void vkb_wire_vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +void vkb_wire_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +void vkb_wire_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +void vkb_wire_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +void vkb_wire_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +void vkb_wire_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +void vkb_wire_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +void vkb_wire_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +void vkb_wire_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void vkb_wire_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +void vkb_wire_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride); +void vkb_wire_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void vkb_wire_vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride); +void vkb_wire_vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset); +void vkb_wire_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer); +void vkb_wire_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +void vkb_wire_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); +void vkb_wire_vkCmdEndRenderPass(VkCommandBuffer commandBuffer); +void vkb_wire_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); +void vkb_wire_vkCmdEndRendering(VkCommandBuffer commandBuffer); +void vkb_wire_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +void vkb_wire_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +void vkb_wire_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +void vkb_wire_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents); +void vkb_wire_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +void vkb_wire_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +void vkb_wire_vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +void vkb_wire_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +void vkb_wire_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); +void vkb_wire_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +void vkb_wire_vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +void vkb_wire_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +void vkb_wire_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +void vkb_wire_vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +void vkb_wire_vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); +void vkb_wire_vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); +void vkb_wire_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]); +void vkb_wire_vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced); +void vkb_wire_vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables); +void vkb_wire_vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations); +void vkb_wire_vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); +void vkb_wire_vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); +void vkb_wire_vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); +void vkb_wire_vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode); +void vkb_wire_vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable); +void vkb_wire_vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable); +void vkb_wire_vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); +void vkb_wire_vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); +void vkb_wire_vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation); +void vkb_wire_vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +void vkb_wire_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +void vkb_wire_vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +void vkb_wire_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +void vkb_wire_vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +void vkb_wire_vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); +void vkb_wire_vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); +void vkb_wire_vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); +void vkb_wire_vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +void vkb_wire_vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +void vkb_wire_vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +void vkb_wire_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask); +void vkb_wire_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); +void vkb_wire_vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); +void vkb_wire_vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); +void vkb_wire_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +void vkb_wire_vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +void vkb_wire_vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); +void vkb_wire_vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); +void vkb_wire_vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +void vkb_wire_vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); +void vkb_wire_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); +void vkb_wire_vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); +void vkb_wire_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth); +void vkb_wire_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp); +void vkb_wire_vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); +void vkb_wire_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints); +void vkb_wire_vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); +void vkb_wire_vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +void vkb_wire_vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +void vkb_wire_vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode); +void vkb_wire_vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); +void vkb_wire_vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream); +void vkb_wire_vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +void vkb_wire_vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); +void vkb_wire_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +void vkb_wire_vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); +void vkb_wire_vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask); +void vkb_wire_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); +void vkb_wire_vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +void vkb_wire_vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); +void vkb_wire_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +void vkb_wire_vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +void vkb_wire_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +void vkb_wire_vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +void vkb_wire_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +void vkb_wire_vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); +void vkb_wire_vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); +void vkb_wire_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); +void vkb_wire_vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles); +void vkb_wire_vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); +void vkb_wire_vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +void vkb_wire_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); +void vkb_wire_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +void vkb_wire_vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +void vkb_wire_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +void vkb_wire_vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +VkResult vkb_wire_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); +VkResult vkb_wire_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); +VkResult vkb_wire_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); +VkResult vkb_wire_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +VkResult vkb_wire_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); +VkResult vkb_wire_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); +VkResult vkb_wire_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +VkResult vkb_wire_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); +VkResult vkb_wire_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); +VkResult vkb_wire_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +VkResult vkb_wire_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); +VkResult vkb_wire_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +VkResult vkb_wire_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); +VkResult vkb_wire_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); +VkResult vkb_wire_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); +VkResult vkb_wire_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); +VkResult vkb_wire_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); +VkResult vkb_wire_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); +VkResult vkb_wire_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +VkResult vkb_wire_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +VkResult vkb_wire_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); +VkResult vkb_wire_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +VkResult vkb_wire_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); +VkResult vkb_wire_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); +void vkb_wire_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); +void vkb_wire_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); +VkResult vkb_wire_vkDeviceWaitIdle(VkDevice device); +VkResult vkb_wire_vkEndCommandBuffer(VkCommandBuffer commandBuffer); +VkResult vkb_wire_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +VkResult vkb_wire_vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +VkResult vkb_wire_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties); +VkResult vkb_wire_vkEnumerateInstanceVersion(uint32_t* pApiVersion); +VkResult vkb_wire_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +VkResult vkb_wire_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +VkResult vkb_wire_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +void vkb_wire_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +VkResult vkb_wire_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); +void vkb_wire_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); +VkDeviceAddress vkb_wire_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +void vkb_wire_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +void vkb_wire_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +uint64_t vkb_wire_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +VkResult vkb_wire_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); +void vkb_wire_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); +void vkb_wire_vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void vkb_wire_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +void vkb_wire_vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void vkb_wire_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +void vkb_wire_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +uint64_t vkb_wire_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +void vkb_wire_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +void vkb_wire_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); +VkResult vkb_wire_vkGetEventStatus(VkDevice device, VkEvent event); +VkResult vkb_wire_vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); +VkResult vkb_wire_vkGetFenceStatus(VkDevice device, VkFence fence); +VkResult vkb_wire_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); +void vkb_wire_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +void vkb_wire_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void vkb_wire_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +void vkb_wire_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +void vkb_wire_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +void vkb_wire_vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout); +VkResult vkb_wire_vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +VkResult vkb_wire_vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); +VkResult vkb_wire_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains); +void vkb_wire_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +void vkb_wire_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +void vkb_wire_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +void vkb_wire_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +void vkb_wire_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +void vkb_wire_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +void vkb_wire_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +VkResult vkb_wire_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); +VkResult vkb_wire_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +VkResult vkb_wire_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +void vkb_wire_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +void vkb_wire_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +void vkb_wire_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); +void vkb_wire_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +void vkb_wire_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +void vkb_wire_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +void vkb_wire_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +void vkb_wire_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); +void vkb_wire_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +VkResult vkb_wire_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +VkResult vkb_wire_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); +VkResult vkb_wire_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); +void vkb_wire_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +VkResult vkb_wire_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +VkResult vkb_wire_vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); +void vkb_wire_vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier); +void vkb_wire_vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier); +VkResult vkb_wire_vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +VkResult vkb_wire_vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +VkResult vkb_wire_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +VkResult vkb_wire_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +VkResult vkb_wire_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); +VkResult vkb_wire_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); +VkResult vkb_wire_vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +VkResult vkb_wire_vkQueueWaitIdle(VkQueue queue); +VkResult vkb_wire_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +VkResult vkb_wire_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +VkResult vkb_wire_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); +VkResult vkb_wire_vkResetEvent(VkDevice device, VkEvent event); +VkResult vkb_wire_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +void vkb_wire_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +void vkb_wire_vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority); +VkResult vkb_wire_vkSetEvent(VkDevice device, VkEvent event); +VkResult vkb_wire_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); +void vkb_wire_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +void vkb_wire_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +VkResult vkb_wire_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +VkResult vkb_wire_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkDeviceWaitIdle(VkDevice device); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEndCommandBuffer(VkCommandBuffer commandBuffer); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumerateInstanceVersion(uint32_t* pApiVersion); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkb_ep_vkGetDeviceProcAddr(VkDevice device, const char* pName); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetFenceStatus(VkDevice device, VkFence fence); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkb_ep_vkGetInstanceProcAddr(VkInstance instance, const char* pName); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +VKAPI_ATTR VkBool32 VKAPI_CALL vkb_ep_vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); +VKAPI_ATTR VkBool32 VKAPI_CALL vkb_ep_vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); +VKAPI_ATTR VkBool32 VKAPI_CALL vkb_ep_vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkQueueEndDebugUtilsLabelEXT(VkQueue queue); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueWaitIdle(VkQueue queue); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkUnmapMemory(VkDevice device, VkDeviceMemory memory); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); +VKAPI_ATTR void VKAPI_CALL vkb_ep_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +#endif diff --git a/tools/vkbridge/common/gen/vkb_gen.h b/tools/vkbridge/common/gen/vkb_gen.h new file mode 100644 index 000000000..6dcab0fe4 --- /dev/null +++ b/tools/vkbridge/common/gen/vkb_gen.h @@ -0,0 +1,2094 @@ +/* Generated by tools/vkbridge/codegen/gen_vkbridge.py from vk.xml 1.3.247 - do not edit. */ +#ifndef VKB_GEN_H +#define VKB_GEN_H +#define VK_NO_PROTOTYPES 1 +#ifdef VKB_CLIENT +#define VK_USE_PLATFORM_WAYLAND_KHR 1 +#define VK_USE_PLATFORM_XCB_KHR 1 +#define VK_USE_PLATFORM_XLIB_KHR 1 +#endif +#include +#include +#include +typedef struct vkb_enc vkb_enc; +typedef struct vkb_dec vkb_dec; +#define VKB_PROTOCOL_HASH 0x89604ff0d8d4e8bdULL +enum vkb_cmd_id { + VKB_CMD_vkbHello = 0, + VKB_CMD_vkbQueryServer = 1, + VKB_CMD_vkbDescUpdateRaw = 2, + VKB_CMD_vkbPushDescRaw = 3, + VKB_CMD_vkAllocateCommandBuffers = 4, + VKB_CMD_vkAllocateDescriptorSets = 5, + VKB_CMD_vkAllocateMemory = 6, + VKB_CMD_vkBeginCommandBuffer = 7, + VKB_CMD_vkBindBufferMemory = 8, + VKB_CMD_vkBindBufferMemory2 = 9, + VKB_CMD_vkBindImageMemory = 10, + VKB_CMD_vkBindImageMemory2 = 11, + VKB_CMD_vkCmdBeginConditionalRenderingEXT = 12, + VKB_CMD_vkCmdBeginQuery = 13, + VKB_CMD_vkCmdBeginQueryIndexedEXT = 14, + VKB_CMD_vkCmdBeginRenderPass = 15, + VKB_CMD_vkCmdBeginRenderPass2 = 16, + VKB_CMD_vkCmdBeginRendering = 17, + VKB_CMD_vkCmdBeginTransformFeedbackEXT = 18, + VKB_CMD_vkCmdBindDescriptorSets = 19, + VKB_CMD_vkCmdBindIndexBuffer = 20, + VKB_CMD_vkCmdBindPipeline = 21, + VKB_CMD_vkCmdBindTransformFeedbackBuffersEXT = 22, + VKB_CMD_vkCmdBindVertexBuffers = 23, + VKB_CMD_vkCmdBindVertexBuffers2 = 24, + VKB_CMD_vkCmdBlitImage = 25, + VKB_CMD_vkCmdBlitImage2 = 26, + VKB_CMD_vkCmdClearAttachments = 27, + VKB_CMD_vkCmdClearColorImage = 28, + VKB_CMD_vkCmdClearDepthStencilImage = 29, + VKB_CMD_vkCmdCopyBuffer = 30, + VKB_CMD_vkCmdCopyBuffer2 = 31, + VKB_CMD_vkCmdCopyBufferToImage = 32, + VKB_CMD_vkCmdCopyBufferToImage2 = 33, + VKB_CMD_vkCmdCopyImage = 34, + VKB_CMD_vkCmdCopyImage2 = 35, + VKB_CMD_vkCmdCopyImageToBuffer = 36, + VKB_CMD_vkCmdCopyImageToBuffer2 = 37, + VKB_CMD_vkCmdCopyQueryPoolResults = 38, + VKB_CMD_vkCmdDispatch = 39, + VKB_CMD_vkCmdDispatchBase = 40, + VKB_CMD_vkCmdDispatchIndirect = 41, + VKB_CMD_vkCmdDraw = 42, + VKB_CMD_vkCmdDrawIndexed = 43, + VKB_CMD_vkCmdDrawIndexedIndirect = 44, + VKB_CMD_vkCmdDrawIndexedIndirectCount = 45, + VKB_CMD_vkCmdDrawIndirect = 46, + VKB_CMD_vkCmdDrawIndirectByteCountEXT = 47, + VKB_CMD_vkCmdDrawIndirectCount = 48, + VKB_CMD_vkCmdDrawMultiEXT = 49, + VKB_CMD_vkCmdDrawMultiIndexedEXT = 50, + VKB_CMD_vkCmdEndConditionalRenderingEXT = 51, + VKB_CMD_vkCmdEndQuery = 52, + VKB_CMD_vkCmdEndQueryIndexedEXT = 53, + VKB_CMD_vkCmdEndRenderPass = 54, + VKB_CMD_vkCmdEndRenderPass2 = 55, + VKB_CMD_vkCmdEndRendering = 56, + VKB_CMD_vkCmdEndTransformFeedbackEXT = 57, + VKB_CMD_vkCmdExecuteCommands = 58, + VKB_CMD_vkCmdFillBuffer = 59, + VKB_CMD_vkCmdNextSubpass = 60, + VKB_CMD_vkCmdNextSubpass2 = 61, + VKB_CMD_vkCmdPipelineBarrier = 62, + VKB_CMD_vkCmdPipelineBarrier2 = 63, + VKB_CMD_vkCmdPushConstants = 64, + VKB_CMD_vkCmdPushDescriptorSetKHR = 65, + VKB_CMD_vkCmdResetEvent = 66, + VKB_CMD_vkCmdResetEvent2 = 67, + VKB_CMD_vkCmdResetQueryPool = 68, + VKB_CMD_vkCmdResolveImage = 69, + VKB_CMD_vkCmdResolveImage2 = 70, + VKB_CMD_vkCmdSetAlphaToCoverageEnableEXT = 71, + VKB_CMD_vkCmdSetAlphaToOneEnableEXT = 72, + VKB_CMD_vkCmdSetBlendConstants = 73, + VKB_CMD_vkCmdSetColorBlendAdvancedEXT = 74, + VKB_CMD_vkCmdSetColorBlendEnableEXT = 75, + VKB_CMD_vkCmdSetColorBlendEquationEXT = 76, + VKB_CMD_vkCmdSetColorWriteEnableEXT = 77, + VKB_CMD_vkCmdSetColorWriteMaskEXT = 78, + VKB_CMD_vkCmdSetConservativeRasterizationModeEXT = 79, + VKB_CMD_vkCmdSetCoverageModulationModeNV = 80, + VKB_CMD_vkCmdSetCoverageModulationTableEnableNV = 81, + VKB_CMD_vkCmdSetCoverageModulationTableNV = 82, + VKB_CMD_vkCmdSetCoverageReductionModeNV = 83, + VKB_CMD_vkCmdSetCoverageToColorEnableNV = 84, + VKB_CMD_vkCmdSetCoverageToColorLocationNV = 85, + VKB_CMD_vkCmdSetCullMode = 86, + VKB_CMD_vkCmdSetDepthBias = 87, + VKB_CMD_vkCmdSetDepthBiasEnable = 88, + VKB_CMD_vkCmdSetDepthBounds = 89, + VKB_CMD_vkCmdSetDepthBoundsTestEnable = 90, + VKB_CMD_vkCmdSetDepthClampEnableEXT = 91, + VKB_CMD_vkCmdSetDepthClipEnableEXT = 92, + VKB_CMD_vkCmdSetDepthClipNegativeOneToOneEXT = 93, + VKB_CMD_vkCmdSetDepthCompareOp = 94, + VKB_CMD_vkCmdSetDepthTestEnable = 95, + VKB_CMD_vkCmdSetDepthWriteEnable = 96, + VKB_CMD_vkCmdSetDeviceMask = 97, + VKB_CMD_vkCmdSetDiscardRectangleEXT = 98, + VKB_CMD_vkCmdSetDiscardRectangleEnableEXT = 99, + VKB_CMD_vkCmdSetDiscardRectangleModeEXT = 100, + VKB_CMD_vkCmdSetEvent = 101, + VKB_CMD_vkCmdSetEvent2 = 102, + VKB_CMD_vkCmdSetExtraPrimitiveOverestimationSizeEXT = 103, + VKB_CMD_vkCmdSetFragmentShadingRateKHR = 104, + VKB_CMD_vkCmdSetFrontFace = 105, + VKB_CMD_vkCmdSetLineRasterizationModeEXT = 106, + VKB_CMD_vkCmdSetLineStippleEXT = 107, + VKB_CMD_vkCmdSetLineStippleEnableEXT = 108, + VKB_CMD_vkCmdSetLineWidth = 109, + VKB_CMD_vkCmdSetLogicOpEXT = 110, + VKB_CMD_vkCmdSetLogicOpEnableEXT = 111, + VKB_CMD_vkCmdSetPatchControlPointsEXT = 112, + VKB_CMD_vkCmdSetPolygonModeEXT = 113, + VKB_CMD_vkCmdSetPrimitiveRestartEnable = 114, + VKB_CMD_vkCmdSetPrimitiveTopology = 115, + VKB_CMD_vkCmdSetProvokingVertexModeEXT = 116, + VKB_CMD_vkCmdSetRasterizationSamplesEXT = 117, + VKB_CMD_vkCmdSetRasterizationStreamEXT = 118, + VKB_CMD_vkCmdSetRasterizerDiscardEnable = 119, + VKB_CMD_vkCmdSetRepresentativeFragmentTestEnableNV = 120, + VKB_CMD_vkCmdSetSampleLocationsEXT = 121, + VKB_CMD_vkCmdSetSampleLocationsEnableEXT = 122, + VKB_CMD_vkCmdSetSampleMaskEXT = 123, + VKB_CMD_vkCmdSetScissor = 124, + VKB_CMD_vkCmdSetScissorWithCount = 125, + VKB_CMD_vkCmdSetShadingRateImageEnableNV = 126, + VKB_CMD_vkCmdSetStencilCompareMask = 127, + VKB_CMD_vkCmdSetStencilOp = 128, + VKB_CMD_vkCmdSetStencilReference = 129, + VKB_CMD_vkCmdSetStencilTestEnable = 130, + VKB_CMD_vkCmdSetStencilWriteMask = 131, + VKB_CMD_vkCmdSetTessellationDomainOriginEXT = 132, + VKB_CMD_vkCmdSetVertexInputEXT = 133, + VKB_CMD_vkCmdSetViewport = 134, + VKB_CMD_vkCmdSetViewportSwizzleNV = 135, + VKB_CMD_vkCmdSetViewportWScalingEnableNV = 136, + VKB_CMD_vkCmdSetViewportWithCount = 137, + VKB_CMD_vkCmdUpdateBuffer = 138, + VKB_CMD_vkCmdWaitEvents = 139, + VKB_CMD_vkCmdWaitEvents2 = 140, + VKB_CMD_vkCmdWriteTimestamp = 141, + VKB_CMD_vkCmdWriteTimestamp2 = 142, + VKB_CMD_vkCreateBuffer = 143, + VKB_CMD_vkCreateBufferView = 144, + VKB_CMD_vkCreateCommandPool = 145, + VKB_CMD_vkCreateComputePipelines = 146, + VKB_CMD_vkCreateDescriptorPool = 147, + VKB_CMD_vkCreateDescriptorSetLayout = 148, + VKB_CMD_vkCreateDescriptorUpdateTemplate = 149, + VKB_CMD_vkCreateDevice = 150, + VKB_CMD_vkCreateEvent = 151, + VKB_CMD_vkCreateFence = 152, + VKB_CMD_vkCreateFramebuffer = 153, + VKB_CMD_vkCreateGraphicsPipelines = 154, + VKB_CMD_vkCreateImage = 155, + VKB_CMD_vkCreateImageView = 156, + VKB_CMD_vkCreateInstance = 157, + VKB_CMD_vkCreatePipelineCache = 158, + VKB_CMD_vkCreatePipelineLayout = 159, + VKB_CMD_vkCreateQueryPool = 160, + VKB_CMD_vkCreateRenderPass = 161, + VKB_CMD_vkCreateRenderPass2 = 162, + VKB_CMD_vkCreateSampler = 163, + VKB_CMD_vkCreateSamplerYcbcrConversion = 164, + VKB_CMD_vkCreateSemaphore = 165, + VKB_CMD_vkCreateShaderModule = 166, + VKB_CMD_vkDestroyBuffer = 167, + VKB_CMD_vkDestroyBufferView = 168, + VKB_CMD_vkDestroyCommandPool = 169, + VKB_CMD_vkDestroyDescriptorPool = 170, + VKB_CMD_vkDestroyDescriptorSetLayout = 171, + VKB_CMD_vkDestroyDescriptorUpdateTemplate = 172, + VKB_CMD_vkDestroyDevice = 173, + VKB_CMD_vkDestroyEvent = 174, + VKB_CMD_vkDestroyFence = 175, + VKB_CMD_vkDestroyFramebuffer = 176, + VKB_CMD_vkDestroyImage = 177, + VKB_CMD_vkDestroyImageView = 178, + VKB_CMD_vkDestroyInstance = 179, + VKB_CMD_vkDestroyPipeline = 180, + VKB_CMD_vkDestroyPipelineCache = 181, + VKB_CMD_vkDestroyPipelineLayout = 182, + VKB_CMD_vkDestroyQueryPool = 183, + VKB_CMD_vkDestroyRenderPass = 184, + VKB_CMD_vkDestroySampler = 185, + VKB_CMD_vkDestroySamplerYcbcrConversion = 186, + VKB_CMD_vkDestroySemaphore = 187, + VKB_CMD_vkDestroyShaderModule = 188, + VKB_CMD_vkDeviceWaitIdle = 189, + VKB_CMD_vkEndCommandBuffer = 190, + VKB_CMD_vkEnumerateDeviceExtensionProperties = 191, + VKB_CMD_vkEnumerateInstanceExtensionProperties = 192, + VKB_CMD_vkEnumerateInstanceLayerProperties = 193, + VKB_CMD_vkEnumerateInstanceVersion = 194, + VKB_CMD_vkEnumeratePhysicalDeviceGroups = 195, + VKB_CMD_vkEnumeratePhysicalDevices = 196, + VKB_CMD_vkFlushMappedMemoryRanges = 197, + VKB_CMD_vkFreeCommandBuffers = 198, + VKB_CMD_vkFreeDescriptorSets = 199, + VKB_CMD_vkFreeMemory = 200, + VKB_CMD_vkGetBufferDeviceAddress = 201, + VKB_CMD_vkGetBufferMemoryRequirements = 202, + VKB_CMD_vkGetBufferMemoryRequirements2 = 203, + VKB_CMD_vkGetBufferOpaqueCaptureAddress = 204, + VKB_CMD_vkGetCalibratedTimestampsEXT = 205, + VKB_CMD_vkGetDescriptorSetLayoutSupport = 206, + VKB_CMD_vkGetDeviceBufferMemoryRequirements = 207, + VKB_CMD_vkGetDeviceGroupPeerMemoryFeatures = 208, + VKB_CMD_vkGetDeviceImageMemoryRequirements = 209, + VKB_CMD_vkGetDeviceImageSparseMemoryRequirements = 210, + VKB_CMD_vkGetDeviceMemoryCommitment = 211, + VKB_CMD_vkGetDeviceMemoryOpaqueCaptureAddress = 212, + VKB_CMD_vkGetDeviceQueue = 213, + VKB_CMD_vkGetDeviceQueue2 = 214, + VKB_CMD_vkGetEventStatus = 215, + VKB_CMD_vkGetFenceFdKHR = 216, + VKB_CMD_vkGetFenceStatus = 217, + VKB_CMD_vkGetImageDrmFormatModifierPropertiesEXT = 218, + VKB_CMD_vkGetImageMemoryRequirements = 219, + VKB_CMD_vkGetImageMemoryRequirements2 = 220, + VKB_CMD_vkGetImageSparseMemoryRequirements = 221, + VKB_CMD_vkGetImageSparseMemoryRequirements2 = 222, + VKB_CMD_vkGetImageSubresourceLayout = 223, + VKB_CMD_vkGetImageSubresourceLayout2EXT = 224, + VKB_CMD_vkGetMemoryFdKHR = 225, + VKB_CMD_vkGetMemoryFdPropertiesKHR = 226, + VKB_CMD_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 227, + VKB_CMD_vkGetPhysicalDeviceExternalBufferProperties = 228, + VKB_CMD_vkGetPhysicalDeviceExternalFenceProperties = 229, + VKB_CMD_vkGetPhysicalDeviceExternalSemaphoreProperties = 230, + VKB_CMD_vkGetPhysicalDeviceFeatures = 231, + VKB_CMD_vkGetPhysicalDeviceFeatures2 = 232, + VKB_CMD_vkGetPhysicalDeviceFormatProperties = 233, + VKB_CMD_vkGetPhysicalDeviceFormatProperties2 = 234, + VKB_CMD_vkGetPhysicalDeviceFragmentShadingRatesKHR = 235, + VKB_CMD_vkGetPhysicalDeviceImageFormatProperties = 236, + VKB_CMD_vkGetPhysicalDeviceImageFormatProperties2 = 237, + VKB_CMD_vkGetPhysicalDeviceMemoryProperties = 238, + VKB_CMD_vkGetPhysicalDeviceMemoryProperties2 = 239, + VKB_CMD_vkGetPhysicalDeviceMultisamplePropertiesEXT = 240, + VKB_CMD_vkGetPhysicalDeviceProperties = 241, + VKB_CMD_vkGetPhysicalDeviceProperties2 = 242, + VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties = 243, + VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties2 = 244, + VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties = 245, + VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties2 = 246, + VKB_CMD_vkGetPhysicalDeviceToolProperties = 247, + VKB_CMD_vkGetPipelineCacheData = 248, + VKB_CMD_vkGetQueryPoolResults = 249, + VKB_CMD_vkGetRenderAreaGranularity = 250, + VKB_CMD_vkGetSemaphoreCounterValue = 251, + VKB_CMD_vkGetSemaphoreFdKHR = 252, + VKB_CMD_vkGetShaderModuleCreateInfoIdentifierEXT = 253, + VKB_CMD_vkGetShaderModuleIdentifierEXT = 254, + VKB_CMD_vkImportFenceFdKHR = 255, + VKB_CMD_vkImportSemaphoreFdKHR = 256, + VKB_CMD_vkInvalidateMappedMemoryRanges = 257, + VKB_CMD_vkMergePipelineCaches = 258, + VKB_CMD_vkQueueBindSparse = 259, + VKB_CMD_vkQueueSubmit = 260, + VKB_CMD_vkQueueSubmit2 = 261, + VKB_CMD_vkQueueWaitIdle = 262, + VKB_CMD_vkResetCommandBuffer = 263, + VKB_CMD_vkResetCommandPool = 264, + VKB_CMD_vkResetDescriptorPool = 265, + VKB_CMD_vkResetEvent = 266, + VKB_CMD_vkResetFences = 267, + VKB_CMD_vkResetQueryPool = 268, + VKB_CMD_vkSetDeviceMemoryPriorityEXT = 269, + VKB_CMD_vkSetEvent = 270, + VKB_CMD_vkSignalSemaphore = 271, + VKB_CMD_vkTrimCommandPool = 272, + VKB_CMD_vkUpdateDescriptorSets = 273, + VKB_CMD_vkWaitForFences = 274, + VKB_CMD_vkWaitSemaphores = 275, + VKB_CMD_COUNT = 276 +}; +extern const char *const vkb_cmd_names[VKB_CMD_COUNT]; + +/* Every bridged command, by its canonical name (aliases resolve to these). */ +typedef struct vkb_dispatch { + PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers; + PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets; + PFN_vkAllocateMemory vkAllocateMemory; + PFN_vkBeginCommandBuffer vkBeginCommandBuffer; + PFN_vkBindBufferMemory vkBindBufferMemory; + PFN_vkBindBufferMemory2 vkBindBufferMemory2; + PFN_vkBindImageMemory vkBindImageMemory; + PFN_vkBindImageMemory2 vkBindImageMemory2; + PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT; + PFN_vkCmdBeginQuery vkCmdBeginQuery; + PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT; + PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass; + PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2; + PFN_vkCmdBeginRendering vkCmdBeginRendering; + PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT; + PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets; + PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer; + PFN_vkCmdBindPipeline vkCmdBindPipeline; + PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT; + PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers; + PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2; + PFN_vkCmdBlitImage vkCmdBlitImage; + PFN_vkCmdBlitImage2 vkCmdBlitImage2; + PFN_vkCmdClearAttachments vkCmdClearAttachments; + PFN_vkCmdClearColorImage vkCmdClearColorImage; + PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage; + PFN_vkCmdCopyBuffer vkCmdCopyBuffer; + PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2; + PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage; + PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2; + PFN_vkCmdCopyImage vkCmdCopyImage; + PFN_vkCmdCopyImage2 vkCmdCopyImage2; + PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer; + PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2; + PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults; + PFN_vkCmdDispatch vkCmdDispatch; + PFN_vkCmdDispatchBase vkCmdDispatchBase; + PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect; + PFN_vkCmdDraw vkCmdDraw; + PFN_vkCmdDrawIndexed vkCmdDrawIndexed; + PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect; + PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount; + PFN_vkCmdDrawIndirect vkCmdDrawIndirect; + PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT; + PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount; + PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT; + PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT; + PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT; + PFN_vkCmdEndQuery vkCmdEndQuery; + PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT; + PFN_vkCmdEndRenderPass vkCmdEndRenderPass; + PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2; + PFN_vkCmdEndRendering vkCmdEndRendering; + PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT; + PFN_vkCmdExecuteCommands vkCmdExecuteCommands; + PFN_vkCmdFillBuffer vkCmdFillBuffer; + PFN_vkCmdNextSubpass vkCmdNextSubpass; + PFN_vkCmdNextSubpass2 vkCmdNextSubpass2; + PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier; + PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2; + PFN_vkCmdPushConstants vkCmdPushConstants; + PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR; + PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR; + PFN_vkCmdResetEvent vkCmdResetEvent; + PFN_vkCmdResetEvent2 vkCmdResetEvent2; + PFN_vkCmdResetQueryPool vkCmdResetQueryPool; + PFN_vkCmdResolveImage vkCmdResolveImage; + PFN_vkCmdResolveImage2 vkCmdResolveImage2; + PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT; + PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT; + PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants; + PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT; + PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT; + PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT; + PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT; + PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT; + PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT; + PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV; + PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV; + PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV; + PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV; + PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV; + PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV; + PFN_vkCmdSetCullMode vkCmdSetCullMode; + PFN_vkCmdSetDepthBias vkCmdSetDepthBias; + PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable; + PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds; + PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable; + PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT; + PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT; + PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT; + PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp; + PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable; + PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable; + PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask; + PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT; + PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT; + PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT; + PFN_vkCmdSetEvent vkCmdSetEvent; + PFN_vkCmdSetEvent2 vkCmdSetEvent2; + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT; + PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR; + PFN_vkCmdSetFrontFace vkCmdSetFrontFace; + PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT; + PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT; + PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT; + PFN_vkCmdSetLineWidth vkCmdSetLineWidth; + PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT; + PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT; + PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT; + PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT; + PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable; + PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology; + PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT; + PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT; + PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT; + PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable; + PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV; + PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT; + PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT; + PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT; + PFN_vkCmdSetScissor vkCmdSetScissor; + PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount; + PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV; + PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask; + PFN_vkCmdSetStencilOp vkCmdSetStencilOp; + PFN_vkCmdSetStencilReference vkCmdSetStencilReference; + PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable; + PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask; + PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT; + PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT; + PFN_vkCmdSetViewport vkCmdSetViewport; + PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV; + PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV; + PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount; + PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer; + PFN_vkCmdWaitEvents vkCmdWaitEvents; + PFN_vkCmdWaitEvents2 vkCmdWaitEvents2; + PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp; + PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2; + PFN_vkCreateBuffer vkCreateBuffer; + PFN_vkCreateBufferView vkCreateBufferView; + PFN_vkCreateCommandPool vkCreateCommandPool; + PFN_vkCreateComputePipelines vkCreateComputePipelines; + PFN_vkCreateDescriptorPool vkCreateDescriptorPool; + PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout; + PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate; + PFN_vkCreateDevice vkCreateDevice; + PFN_vkCreateEvent vkCreateEvent; + PFN_vkCreateFence vkCreateFence; + PFN_vkCreateFramebuffer vkCreateFramebuffer; + PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines; + PFN_vkCreateImage vkCreateImage; + PFN_vkCreateImageView vkCreateImageView; + PFN_vkCreateInstance vkCreateInstance; + PFN_vkCreatePipelineCache vkCreatePipelineCache; + PFN_vkCreatePipelineLayout vkCreatePipelineLayout; + PFN_vkCreateQueryPool vkCreateQueryPool; + PFN_vkCreateRenderPass vkCreateRenderPass; + PFN_vkCreateRenderPass2 vkCreateRenderPass2; + PFN_vkCreateSampler vkCreateSampler; + PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion; + PFN_vkCreateSemaphore vkCreateSemaphore; + PFN_vkCreateShaderModule vkCreateShaderModule; + PFN_vkDestroyBuffer vkDestroyBuffer; + PFN_vkDestroyBufferView vkDestroyBufferView; + PFN_vkDestroyCommandPool vkDestroyCommandPool; + PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool; + PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout; + PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate; + PFN_vkDestroyDevice vkDestroyDevice; + PFN_vkDestroyEvent vkDestroyEvent; + PFN_vkDestroyFence vkDestroyFence; + PFN_vkDestroyFramebuffer vkDestroyFramebuffer; + PFN_vkDestroyImage vkDestroyImage; + PFN_vkDestroyImageView vkDestroyImageView; + PFN_vkDestroyInstance vkDestroyInstance; + PFN_vkDestroyPipeline vkDestroyPipeline; + PFN_vkDestroyPipelineCache vkDestroyPipelineCache; + PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout; + PFN_vkDestroyQueryPool vkDestroyQueryPool; + PFN_vkDestroyRenderPass vkDestroyRenderPass; + PFN_vkDestroySampler vkDestroySampler; + PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion; + PFN_vkDestroySemaphore vkDestroySemaphore; + PFN_vkDestroyShaderModule vkDestroyShaderModule; + PFN_vkDeviceWaitIdle vkDeviceWaitIdle; + PFN_vkEndCommandBuffer vkEndCommandBuffer; + PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties; + PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties; + PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties; + PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion; + PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups; + PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices; + PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges; + PFN_vkFreeCommandBuffers vkFreeCommandBuffers; + PFN_vkFreeDescriptorSets vkFreeDescriptorSets; + PFN_vkFreeMemory vkFreeMemory; + PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress; + PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements; + PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2; + PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress; + PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT; + PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport; + PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements; + PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures; + PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements; + PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements; + PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment; + PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress; + PFN_vkGetDeviceQueue vkGetDeviceQueue; + PFN_vkGetDeviceQueue2 vkGetDeviceQueue2; + PFN_vkGetEventStatus vkGetEventStatus; + PFN_vkGetFenceFdKHR vkGetFenceFdKHR; + PFN_vkGetFenceStatus vkGetFenceStatus; + PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT; + PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements; + PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2; + PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements; + PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2; + PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout; + PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT; + PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR; + PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR; + PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT; + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; + PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties; + PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties; + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties; + PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures; + PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2; + PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties; + PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2; + PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR; + PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties; + PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2; + PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties; + PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2; + PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT; + PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties; + PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2; + PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2; + PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties; + PFN_vkGetPipelineCacheData vkGetPipelineCacheData; + PFN_vkGetQueryPoolResults vkGetQueryPoolResults; + PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity; + PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue; + PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR; + PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT; + PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT; + PFN_vkImportFenceFdKHR vkImportFenceFdKHR; + PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR; + PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges; + PFN_vkMapMemory vkMapMemory; + PFN_vkMergePipelineCaches vkMergePipelineCaches; + PFN_vkQueueBindSparse vkQueueBindSparse; + PFN_vkQueueSubmit vkQueueSubmit; + PFN_vkQueueSubmit2 vkQueueSubmit2; + PFN_vkQueueWaitIdle vkQueueWaitIdle; + PFN_vkResetCommandBuffer vkResetCommandBuffer; + PFN_vkResetCommandPool vkResetCommandPool; + PFN_vkResetDescriptorPool vkResetDescriptorPool; + PFN_vkResetEvent vkResetEvent; + PFN_vkResetFences vkResetFences; + PFN_vkResetQueryPool vkResetQueryPool; + PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT; + PFN_vkSetEvent vkSetEvent; + PFN_vkSignalSemaphore vkSignalSemaphore; + PFN_vkTrimCommandPool vkTrimCommandPool; + PFN_vkUnmapMemory vkUnmapMemory; + PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate; + PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets; + PFN_vkWaitForFences vkWaitForFences; + PFN_vkWaitSemaphores vkWaitSemaphores; +} vkb_dispatch; +void vkb_dispatch_load_instance(vkb_dispatch *dt, PFN_vkGetInstanceProcAddr gipa, VkInstance instance); +void vkb_dispatch_load_device(vkb_dispatch *dt, PFN_vkGetDeviceProcAddr gdpa, VkDevice device); + +size_t vkb_struct_size(VkStructureType t); +void vkb_enc_chain_elem(vkb_enc *e, const VkBaseInStructure *b); +void vkb_dec_chain_elem(vkb_dec *d, VkStructureType t, void *dst); +void vkb_enc_VkApplicationInfo(vkb_enc *e, const VkApplicationInfo *s); +void vkb_encfix_VkApplicationInfo(vkb_enc *e, const VkApplicationInfo *s, size_t raw); +void vkb_dec_VkApplicationInfo(vkb_dec *d, VkApplicationInfo *s); +void vkb_decfix_VkApplicationInfo(vkb_dec *d, VkApplicationInfo *s); +void vkb_enc_VkAttachmentDescription2(vkb_enc *e, const VkAttachmentDescription2 *s); +void vkb_encfix_VkAttachmentDescription2(vkb_enc *e, const VkAttachmentDescription2 *s, size_t raw); +void vkb_dec_VkAttachmentDescription2(vkb_dec *d, VkAttachmentDescription2 *s); +void vkb_decfix_VkAttachmentDescription2(vkb_dec *d, VkAttachmentDescription2 *s); +void vkb_enc_VkAttachmentDescriptionStencilLayout(vkb_enc *e, const VkAttachmentDescriptionStencilLayout *s); +void vkb_encfix_VkAttachmentDescriptionStencilLayout(vkb_enc *e, const VkAttachmentDescriptionStencilLayout *s, size_t raw); +void vkb_dec_VkAttachmentDescriptionStencilLayout(vkb_dec *d, VkAttachmentDescriptionStencilLayout *s); +void vkb_decfix_VkAttachmentDescriptionStencilLayout(vkb_dec *d, VkAttachmentDescriptionStencilLayout *s); +void vkb_enc_VkAttachmentReference2(vkb_enc *e, const VkAttachmentReference2 *s); +void vkb_encfix_VkAttachmentReference2(vkb_enc *e, const VkAttachmentReference2 *s, size_t raw); +void vkb_dec_VkAttachmentReference2(vkb_dec *d, VkAttachmentReference2 *s); +void vkb_decfix_VkAttachmentReference2(vkb_dec *d, VkAttachmentReference2 *s); +void vkb_enc_VkAttachmentReferenceStencilLayout(vkb_enc *e, const VkAttachmentReferenceStencilLayout *s); +void vkb_encfix_VkAttachmentReferenceStencilLayout(vkb_enc *e, const VkAttachmentReferenceStencilLayout *s, size_t raw); +void vkb_dec_VkAttachmentReferenceStencilLayout(vkb_dec *d, VkAttachmentReferenceStencilLayout *s); +void vkb_decfix_VkAttachmentReferenceStencilLayout(vkb_dec *d, VkAttachmentReferenceStencilLayout *s); +void vkb_enc_VkAttachmentSampleLocationsEXT(vkb_enc *e, const VkAttachmentSampleLocationsEXT *s); +void vkb_encfix_VkAttachmentSampleLocationsEXT(vkb_enc *e, const VkAttachmentSampleLocationsEXT *s, size_t raw); +void vkb_dec_VkAttachmentSampleLocationsEXT(vkb_dec *d, VkAttachmentSampleLocationsEXT *s); +void vkb_decfix_VkAttachmentSampleLocationsEXT(vkb_dec *d, VkAttachmentSampleLocationsEXT *s); +void vkb_enc_VkBindBufferMemoryDeviceGroupInfo(vkb_enc *e, const VkBindBufferMemoryDeviceGroupInfo *s); +void vkb_encfix_VkBindBufferMemoryDeviceGroupInfo(vkb_enc *e, const VkBindBufferMemoryDeviceGroupInfo *s, size_t raw); +void vkb_dec_VkBindBufferMemoryDeviceGroupInfo(vkb_dec *d, VkBindBufferMemoryDeviceGroupInfo *s); +void vkb_decfix_VkBindBufferMemoryDeviceGroupInfo(vkb_dec *d, VkBindBufferMemoryDeviceGroupInfo *s); +void vkb_enc_VkBindBufferMemoryInfo(vkb_enc *e, const VkBindBufferMemoryInfo *s); +void vkb_encfix_VkBindBufferMemoryInfo(vkb_enc *e, const VkBindBufferMemoryInfo *s, size_t raw); +void vkb_dec_VkBindBufferMemoryInfo(vkb_dec *d, VkBindBufferMemoryInfo *s); +void vkb_decfix_VkBindBufferMemoryInfo(vkb_dec *d, VkBindBufferMemoryInfo *s); +void vkb_enc_VkBindImageMemoryDeviceGroupInfo(vkb_enc *e, const VkBindImageMemoryDeviceGroupInfo *s); +void vkb_encfix_VkBindImageMemoryDeviceGroupInfo(vkb_enc *e, const VkBindImageMemoryDeviceGroupInfo *s, size_t raw); +void vkb_dec_VkBindImageMemoryDeviceGroupInfo(vkb_dec *d, VkBindImageMemoryDeviceGroupInfo *s); +void vkb_decfix_VkBindImageMemoryDeviceGroupInfo(vkb_dec *d, VkBindImageMemoryDeviceGroupInfo *s); +void vkb_enc_VkBindImageMemoryInfo(vkb_enc *e, const VkBindImageMemoryInfo *s); +void vkb_encfix_VkBindImageMemoryInfo(vkb_enc *e, const VkBindImageMemoryInfo *s, size_t raw); +void vkb_dec_VkBindImageMemoryInfo(vkb_dec *d, VkBindImageMemoryInfo *s); +void vkb_decfix_VkBindImageMemoryInfo(vkb_dec *d, VkBindImageMemoryInfo *s); +void vkb_enc_VkBindImageMemorySwapchainInfoKHR(vkb_enc *e, const VkBindImageMemorySwapchainInfoKHR *s); +void vkb_encfix_VkBindImageMemorySwapchainInfoKHR(vkb_enc *e, const VkBindImageMemorySwapchainInfoKHR *s, size_t raw); +void vkb_dec_VkBindImageMemorySwapchainInfoKHR(vkb_dec *d, VkBindImageMemorySwapchainInfoKHR *s); +void vkb_decfix_VkBindImageMemorySwapchainInfoKHR(vkb_dec *d, VkBindImageMemorySwapchainInfoKHR *s); +void vkb_enc_VkBindImagePlaneMemoryInfo(vkb_enc *e, const VkBindImagePlaneMemoryInfo *s); +void vkb_encfix_VkBindImagePlaneMemoryInfo(vkb_enc *e, const VkBindImagePlaneMemoryInfo *s, size_t raw); +void vkb_dec_VkBindImagePlaneMemoryInfo(vkb_dec *d, VkBindImagePlaneMemoryInfo *s); +void vkb_decfix_VkBindImagePlaneMemoryInfo(vkb_dec *d, VkBindImagePlaneMemoryInfo *s); +void vkb_enc_VkBindSparseInfo(vkb_enc *e, const VkBindSparseInfo *s); +void vkb_encfix_VkBindSparseInfo(vkb_enc *e, const VkBindSparseInfo *s, size_t raw); +void vkb_dec_VkBindSparseInfo(vkb_dec *d, VkBindSparseInfo *s); +void vkb_decfix_VkBindSparseInfo(vkb_dec *d, VkBindSparseInfo *s); +void vkb_enc_VkBlitImageInfo2(vkb_enc *e, const VkBlitImageInfo2 *s); +void vkb_encfix_VkBlitImageInfo2(vkb_enc *e, const VkBlitImageInfo2 *s, size_t raw); +void vkb_dec_VkBlitImageInfo2(vkb_dec *d, VkBlitImageInfo2 *s); +void vkb_decfix_VkBlitImageInfo2(vkb_dec *d, VkBlitImageInfo2 *s); +void vkb_enc_VkBufferCopy2(vkb_enc *e, const VkBufferCopy2 *s); +void vkb_encfix_VkBufferCopy2(vkb_enc *e, const VkBufferCopy2 *s, size_t raw); +void vkb_dec_VkBufferCopy2(vkb_dec *d, VkBufferCopy2 *s); +void vkb_decfix_VkBufferCopy2(vkb_dec *d, VkBufferCopy2 *s); +void vkb_enc_VkBufferCreateInfo(vkb_enc *e, const VkBufferCreateInfo *s); +void vkb_encfix_VkBufferCreateInfo(vkb_enc *e, const VkBufferCreateInfo *s, size_t raw); +void vkb_dec_VkBufferCreateInfo(vkb_dec *d, VkBufferCreateInfo *s); +void vkb_decfix_VkBufferCreateInfo(vkb_dec *d, VkBufferCreateInfo *s); +void vkb_enc_VkBufferDeviceAddressCreateInfoEXT(vkb_enc *e, const VkBufferDeviceAddressCreateInfoEXT *s); +void vkb_encfix_VkBufferDeviceAddressCreateInfoEXT(vkb_enc *e, const VkBufferDeviceAddressCreateInfoEXT *s, size_t raw); +void vkb_dec_VkBufferDeviceAddressCreateInfoEXT(vkb_dec *d, VkBufferDeviceAddressCreateInfoEXT *s); +void vkb_decfix_VkBufferDeviceAddressCreateInfoEXT(vkb_dec *d, VkBufferDeviceAddressCreateInfoEXT *s); +void vkb_enc_VkBufferDeviceAddressInfo(vkb_enc *e, const VkBufferDeviceAddressInfo *s); +void vkb_encfix_VkBufferDeviceAddressInfo(vkb_enc *e, const VkBufferDeviceAddressInfo *s, size_t raw); +void vkb_dec_VkBufferDeviceAddressInfo(vkb_dec *d, VkBufferDeviceAddressInfo *s); +void vkb_decfix_VkBufferDeviceAddressInfo(vkb_dec *d, VkBufferDeviceAddressInfo *s); +void vkb_enc_VkBufferImageCopy2(vkb_enc *e, const VkBufferImageCopy2 *s); +void vkb_encfix_VkBufferImageCopy2(vkb_enc *e, const VkBufferImageCopy2 *s, size_t raw); +void vkb_dec_VkBufferImageCopy2(vkb_dec *d, VkBufferImageCopy2 *s); +void vkb_decfix_VkBufferImageCopy2(vkb_dec *d, VkBufferImageCopy2 *s); +void vkb_enc_VkBufferMemoryBarrier(vkb_enc *e, const VkBufferMemoryBarrier *s); +void vkb_encfix_VkBufferMemoryBarrier(vkb_enc *e, const VkBufferMemoryBarrier *s, size_t raw); +void vkb_dec_VkBufferMemoryBarrier(vkb_dec *d, VkBufferMemoryBarrier *s); +void vkb_decfix_VkBufferMemoryBarrier(vkb_dec *d, VkBufferMemoryBarrier *s); +void vkb_enc_VkBufferMemoryBarrier2(vkb_enc *e, const VkBufferMemoryBarrier2 *s); +void vkb_encfix_VkBufferMemoryBarrier2(vkb_enc *e, const VkBufferMemoryBarrier2 *s, size_t raw); +void vkb_dec_VkBufferMemoryBarrier2(vkb_dec *d, VkBufferMemoryBarrier2 *s); +void vkb_decfix_VkBufferMemoryBarrier2(vkb_dec *d, VkBufferMemoryBarrier2 *s); +void vkb_enc_VkBufferMemoryRequirementsInfo2(vkb_enc *e, const VkBufferMemoryRequirementsInfo2 *s); +void vkb_encfix_VkBufferMemoryRequirementsInfo2(vkb_enc *e, const VkBufferMemoryRequirementsInfo2 *s, size_t raw); +void vkb_dec_VkBufferMemoryRequirementsInfo2(vkb_dec *d, VkBufferMemoryRequirementsInfo2 *s); +void vkb_decfix_VkBufferMemoryRequirementsInfo2(vkb_dec *d, VkBufferMemoryRequirementsInfo2 *s); +void vkb_enc_VkBufferOpaqueCaptureAddressCreateInfo(vkb_enc *e, const VkBufferOpaqueCaptureAddressCreateInfo *s); +void vkb_encfix_VkBufferOpaqueCaptureAddressCreateInfo(vkb_enc *e, const VkBufferOpaqueCaptureAddressCreateInfo *s, size_t raw); +void vkb_dec_VkBufferOpaqueCaptureAddressCreateInfo(vkb_dec *d, VkBufferOpaqueCaptureAddressCreateInfo *s); +void vkb_decfix_VkBufferOpaqueCaptureAddressCreateInfo(vkb_dec *d, VkBufferOpaqueCaptureAddressCreateInfo *s); +void vkb_enc_VkBufferViewCreateInfo(vkb_enc *e, const VkBufferViewCreateInfo *s); +void vkb_encfix_VkBufferViewCreateInfo(vkb_enc *e, const VkBufferViewCreateInfo *s, size_t raw); +void vkb_dec_VkBufferViewCreateInfo(vkb_dec *d, VkBufferViewCreateInfo *s); +void vkb_decfix_VkBufferViewCreateInfo(vkb_dec *d, VkBufferViewCreateInfo *s); +void vkb_enc_VkCalibratedTimestampInfoEXT(vkb_enc *e, const VkCalibratedTimestampInfoEXT *s); +void vkb_encfix_VkCalibratedTimestampInfoEXT(vkb_enc *e, const VkCalibratedTimestampInfoEXT *s, size_t raw); +void vkb_dec_VkCalibratedTimestampInfoEXT(vkb_dec *d, VkCalibratedTimestampInfoEXT *s); +void vkb_decfix_VkCalibratedTimestampInfoEXT(vkb_dec *d, VkCalibratedTimestampInfoEXT *s); +void vkb_enc_VkCommandBufferAllocateInfo(vkb_enc *e, const VkCommandBufferAllocateInfo *s); +void vkb_encfix_VkCommandBufferAllocateInfo(vkb_enc *e, const VkCommandBufferAllocateInfo *s, size_t raw); +void vkb_dec_VkCommandBufferAllocateInfo(vkb_dec *d, VkCommandBufferAllocateInfo *s); +void vkb_decfix_VkCommandBufferAllocateInfo(vkb_dec *d, VkCommandBufferAllocateInfo *s); +void vkb_enc_VkCommandBufferBeginInfo(vkb_enc *e, const VkCommandBufferBeginInfo *s); +void vkb_encfix_VkCommandBufferBeginInfo(vkb_enc *e, const VkCommandBufferBeginInfo *s, size_t raw); +void vkb_dec_VkCommandBufferBeginInfo(vkb_dec *d, VkCommandBufferBeginInfo *s); +void vkb_decfix_VkCommandBufferBeginInfo(vkb_dec *d, VkCommandBufferBeginInfo *s); +void vkb_enc_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkb_enc *e, const VkCommandBufferInheritanceConditionalRenderingInfoEXT *s); +void vkb_encfix_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkb_enc *e, const VkCommandBufferInheritanceConditionalRenderingInfoEXT *s, size_t raw); +void vkb_dec_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkb_dec *d, VkCommandBufferInheritanceConditionalRenderingInfoEXT *s); +void vkb_decfix_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkb_dec *d, VkCommandBufferInheritanceConditionalRenderingInfoEXT *s); +void vkb_enc_VkCommandBufferInheritanceInfo(vkb_enc *e, const VkCommandBufferInheritanceInfo *s); +void vkb_encfix_VkCommandBufferInheritanceInfo(vkb_enc *e, const VkCommandBufferInheritanceInfo *s, size_t raw); +void vkb_dec_VkCommandBufferInheritanceInfo(vkb_dec *d, VkCommandBufferInheritanceInfo *s); +void vkb_decfix_VkCommandBufferInheritanceInfo(vkb_dec *d, VkCommandBufferInheritanceInfo *s); +void vkb_enc_VkCommandBufferInheritanceRenderingInfo(vkb_enc *e, const VkCommandBufferInheritanceRenderingInfo *s); +void vkb_encfix_VkCommandBufferInheritanceRenderingInfo(vkb_enc *e, const VkCommandBufferInheritanceRenderingInfo *s, size_t raw); +void vkb_dec_VkCommandBufferInheritanceRenderingInfo(vkb_dec *d, VkCommandBufferInheritanceRenderingInfo *s); +void vkb_decfix_VkCommandBufferInheritanceRenderingInfo(vkb_dec *d, VkCommandBufferInheritanceRenderingInfo *s); +void vkb_enc_VkCommandBufferSubmitInfo(vkb_enc *e, const VkCommandBufferSubmitInfo *s); +void vkb_encfix_VkCommandBufferSubmitInfo(vkb_enc *e, const VkCommandBufferSubmitInfo *s, size_t raw); +void vkb_dec_VkCommandBufferSubmitInfo(vkb_dec *d, VkCommandBufferSubmitInfo *s); +void vkb_decfix_VkCommandBufferSubmitInfo(vkb_dec *d, VkCommandBufferSubmitInfo *s); +void vkb_enc_VkCommandPoolCreateInfo(vkb_enc *e, const VkCommandPoolCreateInfo *s); +void vkb_encfix_VkCommandPoolCreateInfo(vkb_enc *e, const VkCommandPoolCreateInfo *s, size_t raw); +void vkb_dec_VkCommandPoolCreateInfo(vkb_dec *d, VkCommandPoolCreateInfo *s); +void vkb_decfix_VkCommandPoolCreateInfo(vkb_dec *d, VkCommandPoolCreateInfo *s); +void vkb_enc_VkComputePipelineCreateInfo(vkb_enc *e, const VkComputePipelineCreateInfo *s); +void vkb_encfix_VkComputePipelineCreateInfo(vkb_enc *e, const VkComputePipelineCreateInfo *s, size_t raw); +void vkb_dec_VkComputePipelineCreateInfo(vkb_dec *d, VkComputePipelineCreateInfo *s); +void vkb_decfix_VkComputePipelineCreateInfo(vkb_dec *d, VkComputePipelineCreateInfo *s); +void vkb_enc_VkConditionalRenderingBeginInfoEXT(vkb_enc *e, const VkConditionalRenderingBeginInfoEXT *s); +void vkb_encfix_VkConditionalRenderingBeginInfoEXT(vkb_enc *e, const VkConditionalRenderingBeginInfoEXT *s, size_t raw); +void vkb_dec_VkConditionalRenderingBeginInfoEXT(vkb_dec *d, VkConditionalRenderingBeginInfoEXT *s); +void vkb_decfix_VkConditionalRenderingBeginInfoEXT(vkb_dec *d, VkConditionalRenderingBeginInfoEXT *s); +void vkb_enc_VkCopyBufferInfo2(vkb_enc *e, const VkCopyBufferInfo2 *s); +void vkb_encfix_VkCopyBufferInfo2(vkb_enc *e, const VkCopyBufferInfo2 *s, size_t raw); +void vkb_dec_VkCopyBufferInfo2(vkb_dec *d, VkCopyBufferInfo2 *s); +void vkb_decfix_VkCopyBufferInfo2(vkb_dec *d, VkCopyBufferInfo2 *s); +void vkb_enc_VkCopyBufferToImageInfo2(vkb_enc *e, const VkCopyBufferToImageInfo2 *s); +void vkb_encfix_VkCopyBufferToImageInfo2(vkb_enc *e, const VkCopyBufferToImageInfo2 *s, size_t raw); +void vkb_dec_VkCopyBufferToImageInfo2(vkb_dec *d, VkCopyBufferToImageInfo2 *s); +void vkb_decfix_VkCopyBufferToImageInfo2(vkb_dec *d, VkCopyBufferToImageInfo2 *s); +void vkb_enc_VkCopyDescriptorSet(vkb_enc *e, const VkCopyDescriptorSet *s); +void vkb_encfix_VkCopyDescriptorSet(vkb_enc *e, const VkCopyDescriptorSet *s, size_t raw); +void vkb_dec_VkCopyDescriptorSet(vkb_dec *d, VkCopyDescriptorSet *s); +void vkb_decfix_VkCopyDescriptorSet(vkb_dec *d, VkCopyDescriptorSet *s); +void vkb_enc_VkCopyImageInfo2(vkb_enc *e, const VkCopyImageInfo2 *s); +void vkb_encfix_VkCopyImageInfo2(vkb_enc *e, const VkCopyImageInfo2 *s, size_t raw); +void vkb_dec_VkCopyImageInfo2(vkb_dec *d, VkCopyImageInfo2 *s); +void vkb_decfix_VkCopyImageInfo2(vkb_dec *d, VkCopyImageInfo2 *s); +void vkb_enc_VkCopyImageToBufferInfo2(vkb_enc *e, const VkCopyImageToBufferInfo2 *s); +void vkb_encfix_VkCopyImageToBufferInfo2(vkb_enc *e, const VkCopyImageToBufferInfo2 *s, size_t raw); +void vkb_dec_VkCopyImageToBufferInfo2(vkb_dec *d, VkCopyImageToBufferInfo2 *s); +void vkb_decfix_VkCopyImageToBufferInfo2(vkb_dec *d, VkCopyImageToBufferInfo2 *s); +void vkb_enc_VkDebugUtilsObjectNameInfoEXT(vkb_enc *e, const VkDebugUtilsObjectNameInfoEXT *s); +void vkb_encfix_VkDebugUtilsObjectNameInfoEXT(vkb_enc *e, const VkDebugUtilsObjectNameInfoEXT *s, size_t raw); +void vkb_dec_VkDebugUtilsObjectNameInfoEXT(vkb_dec *d, VkDebugUtilsObjectNameInfoEXT *s); +void vkb_decfix_VkDebugUtilsObjectNameInfoEXT(vkb_dec *d, VkDebugUtilsObjectNameInfoEXT *s); +void vkb_enc_VkDependencyInfo(vkb_enc *e, const VkDependencyInfo *s); +void vkb_encfix_VkDependencyInfo(vkb_enc *e, const VkDependencyInfo *s, size_t raw); +void vkb_dec_VkDependencyInfo(vkb_dec *d, VkDependencyInfo *s); +void vkb_decfix_VkDependencyInfo(vkb_dec *d, VkDependencyInfo *s); +void vkb_enc_VkDescriptorPoolCreateInfo(vkb_enc *e, const VkDescriptorPoolCreateInfo *s); +void vkb_encfix_VkDescriptorPoolCreateInfo(vkb_enc *e, const VkDescriptorPoolCreateInfo *s, size_t raw); +void vkb_dec_VkDescriptorPoolCreateInfo(vkb_dec *d, VkDescriptorPoolCreateInfo *s); +void vkb_decfix_VkDescriptorPoolCreateInfo(vkb_dec *d, VkDescriptorPoolCreateInfo *s); +void vkb_enc_VkDescriptorPoolInlineUniformBlockCreateInfo(vkb_enc *e, const VkDescriptorPoolInlineUniformBlockCreateInfo *s); +void vkb_encfix_VkDescriptorPoolInlineUniformBlockCreateInfo(vkb_enc *e, const VkDescriptorPoolInlineUniformBlockCreateInfo *s, size_t raw); +void vkb_dec_VkDescriptorPoolInlineUniformBlockCreateInfo(vkb_dec *d, VkDescriptorPoolInlineUniformBlockCreateInfo *s); +void vkb_decfix_VkDescriptorPoolInlineUniformBlockCreateInfo(vkb_dec *d, VkDescriptorPoolInlineUniformBlockCreateInfo *s); +void vkb_enc_VkDescriptorSetAllocateInfo(vkb_enc *e, const VkDescriptorSetAllocateInfo *s); +void vkb_encfix_VkDescriptorSetAllocateInfo(vkb_enc *e, const VkDescriptorSetAllocateInfo *s, size_t raw); +void vkb_dec_VkDescriptorSetAllocateInfo(vkb_dec *d, VkDescriptorSetAllocateInfo *s); +void vkb_decfix_VkDescriptorSetAllocateInfo(vkb_dec *d, VkDescriptorSetAllocateInfo *s); +void vkb_enc_VkDescriptorSetLayoutBinding(vkb_enc *e, const VkDescriptorSetLayoutBinding *s); +void vkb_encfix_VkDescriptorSetLayoutBinding(vkb_enc *e, const VkDescriptorSetLayoutBinding *s, size_t raw); +void vkb_dec_VkDescriptorSetLayoutBinding(vkb_dec *d, VkDescriptorSetLayoutBinding *s); +void vkb_decfix_VkDescriptorSetLayoutBinding(vkb_dec *d, VkDescriptorSetLayoutBinding *s); +void vkb_enc_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkb_enc *e, const VkDescriptorSetLayoutBindingFlagsCreateInfo *s); +void vkb_encfix_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkb_enc *e, const VkDescriptorSetLayoutBindingFlagsCreateInfo *s, size_t raw); +void vkb_dec_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkb_dec *d, VkDescriptorSetLayoutBindingFlagsCreateInfo *s); +void vkb_decfix_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkb_dec *d, VkDescriptorSetLayoutBindingFlagsCreateInfo *s); +void vkb_enc_VkDescriptorSetLayoutCreateInfo(vkb_enc *e, const VkDescriptorSetLayoutCreateInfo *s); +void vkb_encfix_VkDescriptorSetLayoutCreateInfo(vkb_enc *e, const VkDescriptorSetLayoutCreateInfo *s, size_t raw); +void vkb_dec_VkDescriptorSetLayoutCreateInfo(vkb_dec *d, VkDescriptorSetLayoutCreateInfo *s); +void vkb_decfix_VkDescriptorSetLayoutCreateInfo(vkb_dec *d, VkDescriptorSetLayoutCreateInfo *s); +void vkb_enc_VkDescriptorSetLayoutSupport(vkb_enc *e, const VkDescriptorSetLayoutSupport *s); +void vkb_encfix_VkDescriptorSetLayoutSupport(vkb_enc *e, const VkDescriptorSetLayoutSupport *s, size_t raw); +void vkb_dec_VkDescriptorSetLayoutSupport(vkb_dec *d, VkDescriptorSetLayoutSupport *s); +void vkb_decfix_VkDescriptorSetLayoutSupport(vkb_dec *d, VkDescriptorSetLayoutSupport *s); +void vkb_enc_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkb_enc *e, const VkDescriptorSetVariableDescriptorCountAllocateInfo *s); +void vkb_encfix_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkb_enc *e, const VkDescriptorSetVariableDescriptorCountAllocateInfo *s, size_t raw); +void vkb_dec_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkb_dec *d, VkDescriptorSetVariableDescriptorCountAllocateInfo *s); +void vkb_decfix_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkb_dec *d, VkDescriptorSetVariableDescriptorCountAllocateInfo *s); +void vkb_enc_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkb_enc *e, const VkDescriptorSetVariableDescriptorCountLayoutSupport *s); +void vkb_encfix_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkb_enc *e, const VkDescriptorSetVariableDescriptorCountLayoutSupport *s, size_t raw); +void vkb_dec_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkb_dec *d, VkDescriptorSetVariableDescriptorCountLayoutSupport *s); +void vkb_decfix_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkb_dec *d, VkDescriptorSetVariableDescriptorCountLayoutSupport *s); +void vkb_enc_VkDescriptorUpdateTemplateCreateInfo(vkb_enc *e, const VkDescriptorUpdateTemplateCreateInfo *s); +void vkb_encfix_VkDescriptorUpdateTemplateCreateInfo(vkb_enc *e, const VkDescriptorUpdateTemplateCreateInfo *s, size_t raw); +void vkb_dec_VkDescriptorUpdateTemplateCreateInfo(vkb_dec *d, VkDescriptorUpdateTemplateCreateInfo *s); +void vkb_decfix_VkDescriptorUpdateTemplateCreateInfo(vkb_dec *d, VkDescriptorUpdateTemplateCreateInfo *s); +void vkb_enc_VkDeviceBufferMemoryRequirements(vkb_enc *e, const VkDeviceBufferMemoryRequirements *s); +void vkb_encfix_VkDeviceBufferMemoryRequirements(vkb_enc *e, const VkDeviceBufferMemoryRequirements *s, size_t raw); +void vkb_dec_VkDeviceBufferMemoryRequirements(vkb_dec *d, VkDeviceBufferMemoryRequirements *s); +void vkb_decfix_VkDeviceBufferMemoryRequirements(vkb_dec *d, VkDeviceBufferMemoryRequirements *s); +void vkb_enc_VkDeviceCreateInfo(vkb_enc *e, const VkDeviceCreateInfo *s); +void vkb_encfix_VkDeviceCreateInfo(vkb_enc *e, const VkDeviceCreateInfo *s, size_t raw); +void vkb_dec_VkDeviceCreateInfo(vkb_dec *d, VkDeviceCreateInfo *s); +void vkb_decfix_VkDeviceCreateInfo(vkb_dec *d, VkDeviceCreateInfo *s); +void vkb_enc_VkDeviceGroupBindSparseInfo(vkb_enc *e, const VkDeviceGroupBindSparseInfo *s); +void vkb_encfix_VkDeviceGroupBindSparseInfo(vkb_enc *e, const VkDeviceGroupBindSparseInfo *s, size_t raw); +void vkb_dec_VkDeviceGroupBindSparseInfo(vkb_dec *d, VkDeviceGroupBindSparseInfo *s); +void vkb_decfix_VkDeviceGroupBindSparseInfo(vkb_dec *d, VkDeviceGroupBindSparseInfo *s); +void vkb_enc_VkDeviceGroupCommandBufferBeginInfo(vkb_enc *e, const VkDeviceGroupCommandBufferBeginInfo *s); +void vkb_encfix_VkDeviceGroupCommandBufferBeginInfo(vkb_enc *e, const VkDeviceGroupCommandBufferBeginInfo *s, size_t raw); +void vkb_dec_VkDeviceGroupCommandBufferBeginInfo(vkb_dec *d, VkDeviceGroupCommandBufferBeginInfo *s); +void vkb_decfix_VkDeviceGroupCommandBufferBeginInfo(vkb_dec *d, VkDeviceGroupCommandBufferBeginInfo *s); +void vkb_enc_VkDeviceGroupDeviceCreateInfo(vkb_enc *e, const VkDeviceGroupDeviceCreateInfo *s); +void vkb_encfix_VkDeviceGroupDeviceCreateInfo(vkb_enc *e, const VkDeviceGroupDeviceCreateInfo *s, size_t raw); +void vkb_dec_VkDeviceGroupDeviceCreateInfo(vkb_dec *d, VkDeviceGroupDeviceCreateInfo *s); +void vkb_decfix_VkDeviceGroupDeviceCreateInfo(vkb_dec *d, VkDeviceGroupDeviceCreateInfo *s); +void vkb_enc_VkDeviceGroupRenderPassBeginInfo(vkb_enc *e, const VkDeviceGroupRenderPassBeginInfo *s); +void vkb_encfix_VkDeviceGroupRenderPassBeginInfo(vkb_enc *e, const VkDeviceGroupRenderPassBeginInfo *s, size_t raw); +void vkb_dec_VkDeviceGroupRenderPassBeginInfo(vkb_dec *d, VkDeviceGroupRenderPassBeginInfo *s); +void vkb_decfix_VkDeviceGroupRenderPassBeginInfo(vkb_dec *d, VkDeviceGroupRenderPassBeginInfo *s); +void vkb_enc_VkDeviceGroupSubmitInfo(vkb_enc *e, const VkDeviceGroupSubmitInfo *s); +void vkb_encfix_VkDeviceGroupSubmitInfo(vkb_enc *e, const VkDeviceGroupSubmitInfo *s, size_t raw); +void vkb_dec_VkDeviceGroupSubmitInfo(vkb_dec *d, VkDeviceGroupSubmitInfo *s); +void vkb_decfix_VkDeviceGroupSubmitInfo(vkb_dec *d, VkDeviceGroupSubmitInfo *s); +void vkb_enc_VkDeviceImageMemoryRequirements(vkb_enc *e, const VkDeviceImageMemoryRequirements *s); +void vkb_encfix_VkDeviceImageMemoryRequirements(vkb_enc *e, const VkDeviceImageMemoryRequirements *s, size_t raw); +void vkb_dec_VkDeviceImageMemoryRequirements(vkb_dec *d, VkDeviceImageMemoryRequirements *s); +void vkb_decfix_VkDeviceImageMemoryRequirements(vkb_dec *d, VkDeviceImageMemoryRequirements *s); +void vkb_enc_VkDeviceMemoryOpaqueCaptureAddressInfo(vkb_enc *e, const VkDeviceMemoryOpaqueCaptureAddressInfo *s); +void vkb_encfix_VkDeviceMemoryOpaqueCaptureAddressInfo(vkb_enc *e, const VkDeviceMemoryOpaqueCaptureAddressInfo *s, size_t raw); +void vkb_dec_VkDeviceMemoryOpaqueCaptureAddressInfo(vkb_dec *d, VkDeviceMemoryOpaqueCaptureAddressInfo *s); +void vkb_decfix_VkDeviceMemoryOpaqueCaptureAddressInfo(vkb_dec *d, VkDeviceMemoryOpaqueCaptureAddressInfo *s); +void vkb_enc_VkDevicePrivateDataCreateInfo(vkb_enc *e, const VkDevicePrivateDataCreateInfo *s); +void vkb_encfix_VkDevicePrivateDataCreateInfo(vkb_enc *e, const VkDevicePrivateDataCreateInfo *s, size_t raw); +void vkb_dec_VkDevicePrivateDataCreateInfo(vkb_dec *d, VkDevicePrivateDataCreateInfo *s); +void vkb_decfix_VkDevicePrivateDataCreateInfo(vkb_dec *d, VkDevicePrivateDataCreateInfo *s); +void vkb_enc_VkDeviceQueueCreateInfo(vkb_enc *e, const VkDeviceQueueCreateInfo *s); +void vkb_encfix_VkDeviceQueueCreateInfo(vkb_enc *e, const VkDeviceQueueCreateInfo *s, size_t raw); +void vkb_dec_VkDeviceQueueCreateInfo(vkb_dec *d, VkDeviceQueueCreateInfo *s); +void vkb_decfix_VkDeviceQueueCreateInfo(vkb_dec *d, VkDeviceQueueCreateInfo *s); +void vkb_enc_VkDeviceQueueGlobalPriorityCreateInfoKHR(vkb_enc *e, const VkDeviceQueueGlobalPriorityCreateInfoKHR *s); +void vkb_encfix_VkDeviceQueueGlobalPriorityCreateInfoKHR(vkb_enc *e, const VkDeviceQueueGlobalPriorityCreateInfoKHR *s, size_t raw); +void vkb_dec_VkDeviceQueueGlobalPriorityCreateInfoKHR(vkb_dec *d, VkDeviceQueueGlobalPriorityCreateInfoKHR *s); +void vkb_decfix_VkDeviceQueueGlobalPriorityCreateInfoKHR(vkb_dec *d, VkDeviceQueueGlobalPriorityCreateInfoKHR *s); +void vkb_enc_VkDeviceQueueInfo2(vkb_enc *e, const VkDeviceQueueInfo2 *s); +void vkb_encfix_VkDeviceQueueInfo2(vkb_enc *e, const VkDeviceQueueInfo2 *s, size_t raw); +void vkb_dec_VkDeviceQueueInfo2(vkb_dec *d, VkDeviceQueueInfo2 *s); +void vkb_decfix_VkDeviceQueueInfo2(vkb_dec *d, VkDeviceQueueInfo2 *s); +void vkb_enc_VkDrmFormatModifierPropertiesList2EXT(vkb_enc *e, const VkDrmFormatModifierPropertiesList2EXT *s); +void vkb_encfix_VkDrmFormatModifierPropertiesList2EXT(vkb_enc *e, const VkDrmFormatModifierPropertiesList2EXT *s, size_t raw); +void vkb_dec_VkDrmFormatModifierPropertiesList2EXT(vkb_dec *d, VkDrmFormatModifierPropertiesList2EXT *s); +void vkb_decfix_VkDrmFormatModifierPropertiesList2EXT(vkb_dec *d, VkDrmFormatModifierPropertiesList2EXT *s); +void vkb_enc_VkDrmFormatModifierPropertiesListEXT(vkb_enc *e, const VkDrmFormatModifierPropertiesListEXT *s); +void vkb_encfix_VkDrmFormatModifierPropertiesListEXT(vkb_enc *e, const VkDrmFormatModifierPropertiesListEXT *s, size_t raw); +void vkb_dec_VkDrmFormatModifierPropertiesListEXT(vkb_dec *d, VkDrmFormatModifierPropertiesListEXT *s); +void vkb_decfix_VkDrmFormatModifierPropertiesListEXT(vkb_dec *d, VkDrmFormatModifierPropertiesListEXT *s); +void vkb_enc_VkEventCreateInfo(vkb_enc *e, const VkEventCreateInfo *s); +void vkb_encfix_VkEventCreateInfo(vkb_enc *e, const VkEventCreateInfo *s, size_t raw); +void vkb_dec_VkEventCreateInfo(vkb_dec *d, VkEventCreateInfo *s); +void vkb_decfix_VkEventCreateInfo(vkb_dec *d, VkEventCreateInfo *s); +void vkb_enc_VkExportFenceCreateInfo(vkb_enc *e, const VkExportFenceCreateInfo *s); +void vkb_encfix_VkExportFenceCreateInfo(vkb_enc *e, const VkExportFenceCreateInfo *s, size_t raw); +void vkb_dec_VkExportFenceCreateInfo(vkb_dec *d, VkExportFenceCreateInfo *s); +void vkb_decfix_VkExportFenceCreateInfo(vkb_dec *d, VkExportFenceCreateInfo *s); +void vkb_enc_VkExportMemoryAllocateInfo(vkb_enc *e, const VkExportMemoryAllocateInfo *s); +void vkb_encfix_VkExportMemoryAllocateInfo(vkb_enc *e, const VkExportMemoryAllocateInfo *s, size_t raw); +void vkb_dec_VkExportMemoryAllocateInfo(vkb_dec *d, VkExportMemoryAllocateInfo *s); +void vkb_decfix_VkExportMemoryAllocateInfo(vkb_dec *d, VkExportMemoryAllocateInfo *s); +void vkb_enc_VkExportSemaphoreCreateInfo(vkb_enc *e, const VkExportSemaphoreCreateInfo *s); +void vkb_encfix_VkExportSemaphoreCreateInfo(vkb_enc *e, const VkExportSemaphoreCreateInfo *s, size_t raw); +void vkb_dec_VkExportSemaphoreCreateInfo(vkb_dec *d, VkExportSemaphoreCreateInfo *s); +void vkb_decfix_VkExportSemaphoreCreateInfo(vkb_dec *d, VkExportSemaphoreCreateInfo *s); +void vkb_enc_VkExternalBufferProperties(vkb_enc *e, const VkExternalBufferProperties *s); +void vkb_encfix_VkExternalBufferProperties(vkb_enc *e, const VkExternalBufferProperties *s, size_t raw); +void vkb_dec_VkExternalBufferProperties(vkb_dec *d, VkExternalBufferProperties *s); +void vkb_decfix_VkExternalBufferProperties(vkb_dec *d, VkExternalBufferProperties *s); +void vkb_enc_VkExternalFenceProperties(vkb_enc *e, const VkExternalFenceProperties *s); +void vkb_encfix_VkExternalFenceProperties(vkb_enc *e, const VkExternalFenceProperties *s, size_t raw); +void vkb_dec_VkExternalFenceProperties(vkb_dec *d, VkExternalFenceProperties *s); +void vkb_decfix_VkExternalFenceProperties(vkb_dec *d, VkExternalFenceProperties *s); +void vkb_enc_VkExternalImageFormatProperties(vkb_enc *e, const VkExternalImageFormatProperties *s); +void vkb_encfix_VkExternalImageFormatProperties(vkb_enc *e, const VkExternalImageFormatProperties *s, size_t raw); +void vkb_dec_VkExternalImageFormatProperties(vkb_dec *d, VkExternalImageFormatProperties *s); +void vkb_decfix_VkExternalImageFormatProperties(vkb_dec *d, VkExternalImageFormatProperties *s); +void vkb_enc_VkExternalMemoryBufferCreateInfo(vkb_enc *e, const VkExternalMemoryBufferCreateInfo *s); +void vkb_encfix_VkExternalMemoryBufferCreateInfo(vkb_enc *e, const VkExternalMemoryBufferCreateInfo *s, size_t raw); +void vkb_dec_VkExternalMemoryBufferCreateInfo(vkb_dec *d, VkExternalMemoryBufferCreateInfo *s); +void vkb_decfix_VkExternalMemoryBufferCreateInfo(vkb_dec *d, VkExternalMemoryBufferCreateInfo *s); +void vkb_enc_VkExternalMemoryImageCreateInfo(vkb_enc *e, const VkExternalMemoryImageCreateInfo *s); +void vkb_encfix_VkExternalMemoryImageCreateInfo(vkb_enc *e, const VkExternalMemoryImageCreateInfo *s, size_t raw); +void vkb_dec_VkExternalMemoryImageCreateInfo(vkb_dec *d, VkExternalMemoryImageCreateInfo *s); +void vkb_decfix_VkExternalMemoryImageCreateInfo(vkb_dec *d, VkExternalMemoryImageCreateInfo *s); +void vkb_enc_VkExternalSemaphoreProperties(vkb_enc *e, const VkExternalSemaphoreProperties *s); +void vkb_encfix_VkExternalSemaphoreProperties(vkb_enc *e, const VkExternalSemaphoreProperties *s, size_t raw); +void vkb_dec_VkExternalSemaphoreProperties(vkb_dec *d, VkExternalSemaphoreProperties *s); +void vkb_decfix_VkExternalSemaphoreProperties(vkb_dec *d, VkExternalSemaphoreProperties *s); +void vkb_enc_VkFenceCreateInfo(vkb_enc *e, const VkFenceCreateInfo *s); +void vkb_encfix_VkFenceCreateInfo(vkb_enc *e, const VkFenceCreateInfo *s, size_t raw); +void vkb_dec_VkFenceCreateInfo(vkb_dec *d, VkFenceCreateInfo *s); +void vkb_decfix_VkFenceCreateInfo(vkb_dec *d, VkFenceCreateInfo *s); +void vkb_enc_VkFenceGetFdInfoKHR(vkb_enc *e, const VkFenceGetFdInfoKHR *s); +void vkb_encfix_VkFenceGetFdInfoKHR(vkb_enc *e, const VkFenceGetFdInfoKHR *s, size_t raw); +void vkb_dec_VkFenceGetFdInfoKHR(vkb_dec *d, VkFenceGetFdInfoKHR *s); +void vkb_decfix_VkFenceGetFdInfoKHR(vkb_dec *d, VkFenceGetFdInfoKHR *s); +void vkb_enc_VkFilterCubicImageViewImageFormatPropertiesEXT(vkb_enc *e, const VkFilterCubicImageViewImageFormatPropertiesEXT *s); +void vkb_encfix_VkFilterCubicImageViewImageFormatPropertiesEXT(vkb_enc *e, const VkFilterCubicImageViewImageFormatPropertiesEXT *s, size_t raw); +void vkb_dec_VkFilterCubicImageViewImageFormatPropertiesEXT(vkb_dec *d, VkFilterCubicImageViewImageFormatPropertiesEXT *s); +void vkb_decfix_VkFilterCubicImageViewImageFormatPropertiesEXT(vkb_dec *d, VkFilterCubicImageViewImageFormatPropertiesEXT *s); +void vkb_enc_VkFormatProperties2(vkb_enc *e, const VkFormatProperties2 *s); +void vkb_encfix_VkFormatProperties2(vkb_enc *e, const VkFormatProperties2 *s, size_t raw); +void vkb_dec_VkFormatProperties2(vkb_dec *d, VkFormatProperties2 *s); +void vkb_decfix_VkFormatProperties2(vkb_dec *d, VkFormatProperties2 *s); +void vkb_enc_VkFormatProperties3(vkb_enc *e, const VkFormatProperties3 *s); +void vkb_encfix_VkFormatProperties3(vkb_enc *e, const VkFormatProperties3 *s, size_t raw); +void vkb_dec_VkFormatProperties3(vkb_dec *d, VkFormatProperties3 *s); +void vkb_decfix_VkFormatProperties3(vkb_dec *d, VkFormatProperties3 *s); +void vkb_enc_VkFragmentShadingRateAttachmentInfoKHR(vkb_enc *e, const VkFragmentShadingRateAttachmentInfoKHR *s); +void vkb_encfix_VkFragmentShadingRateAttachmentInfoKHR(vkb_enc *e, const VkFragmentShadingRateAttachmentInfoKHR *s, size_t raw); +void vkb_dec_VkFragmentShadingRateAttachmentInfoKHR(vkb_dec *d, VkFragmentShadingRateAttachmentInfoKHR *s); +void vkb_decfix_VkFragmentShadingRateAttachmentInfoKHR(vkb_dec *d, VkFragmentShadingRateAttachmentInfoKHR *s); +void vkb_enc_VkFramebufferAttachmentImageInfo(vkb_enc *e, const VkFramebufferAttachmentImageInfo *s); +void vkb_encfix_VkFramebufferAttachmentImageInfo(vkb_enc *e, const VkFramebufferAttachmentImageInfo *s, size_t raw); +void vkb_dec_VkFramebufferAttachmentImageInfo(vkb_dec *d, VkFramebufferAttachmentImageInfo *s); +void vkb_decfix_VkFramebufferAttachmentImageInfo(vkb_dec *d, VkFramebufferAttachmentImageInfo *s); +void vkb_enc_VkFramebufferAttachmentsCreateInfo(vkb_enc *e, const VkFramebufferAttachmentsCreateInfo *s); +void vkb_encfix_VkFramebufferAttachmentsCreateInfo(vkb_enc *e, const VkFramebufferAttachmentsCreateInfo *s, size_t raw); +void vkb_dec_VkFramebufferAttachmentsCreateInfo(vkb_dec *d, VkFramebufferAttachmentsCreateInfo *s); +void vkb_decfix_VkFramebufferAttachmentsCreateInfo(vkb_dec *d, VkFramebufferAttachmentsCreateInfo *s); +void vkb_enc_VkFramebufferCreateInfo(vkb_enc *e, const VkFramebufferCreateInfo *s); +void vkb_encfix_VkFramebufferCreateInfo(vkb_enc *e, const VkFramebufferCreateInfo *s, size_t raw); +void vkb_dec_VkFramebufferCreateInfo(vkb_dec *d, VkFramebufferCreateInfo *s); +void vkb_decfix_VkFramebufferCreateInfo(vkb_dec *d, VkFramebufferCreateInfo *s); +void vkb_enc_VkGraphicsPipelineCreateInfo(vkb_enc *e, const VkGraphicsPipelineCreateInfo *s); +void vkb_encfix_VkGraphicsPipelineCreateInfo(vkb_enc *e, const VkGraphicsPipelineCreateInfo *s, size_t raw); +void vkb_dec_VkGraphicsPipelineCreateInfo(vkb_dec *d, VkGraphicsPipelineCreateInfo *s); +void vkb_decfix_VkGraphicsPipelineCreateInfo(vkb_dec *d, VkGraphicsPipelineCreateInfo *s); +void vkb_enc_VkGraphicsPipelineLibraryCreateInfoEXT(vkb_enc *e, const VkGraphicsPipelineLibraryCreateInfoEXT *s); +void vkb_encfix_VkGraphicsPipelineLibraryCreateInfoEXT(vkb_enc *e, const VkGraphicsPipelineLibraryCreateInfoEXT *s, size_t raw); +void vkb_dec_VkGraphicsPipelineLibraryCreateInfoEXT(vkb_dec *d, VkGraphicsPipelineLibraryCreateInfoEXT *s); +void vkb_decfix_VkGraphicsPipelineLibraryCreateInfoEXT(vkb_dec *d, VkGraphicsPipelineLibraryCreateInfoEXT *s); +void vkb_enc_VkImageBlit2(vkb_enc *e, const VkImageBlit2 *s); +void vkb_encfix_VkImageBlit2(vkb_enc *e, const VkImageBlit2 *s, size_t raw); +void vkb_dec_VkImageBlit2(vkb_dec *d, VkImageBlit2 *s); +void vkb_decfix_VkImageBlit2(vkb_dec *d, VkImageBlit2 *s); +void vkb_enc_VkImageCompressionControlEXT(vkb_enc *e, const VkImageCompressionControlEXT *s); +void vkb_encfix_VkImageCompressionControlEXT(vkb_enc *e, const VkImageCompressionControlEXT *s, size_t raw); +void vkb_dec_VkImageCompressionControlEXT(vkb_dec *d, VkImageCompressionControlEXT *s); +void vkb_decfix_VkImageCompressionControlEXT(vkb_dec *d, VkImageCompressionControlEXT *s); +void vkb_enc_VkImageCompressionPropertiesEXT(vkb_enc *e, const VkImageCompressionPropertiesEXT *s); +void vkb_encfix_VkImageCompressionPropertiesEXT(vkb_enc *e, const VkImageCompressionPropertiesEXT *s, size_t raw); +void vkb_dec_VkImageCompressionPropertiesEXT(vkb_dec *d, VkImageCompressionPropertiesEXT *s); +void vkb_decfix_VkImageCompressionPropertiesEXT(vkb_dec *d, VkImageCompressionPropertiesEXT *s); +void vkb_enc_VkImageCopy2(vkb_enc *e, const VkImageCopy2 *s); +void vkb_encfix_VkImageCopy2(vkb_enc *e, const VkImageCopy2 *s, size_t raw); +void vkb_dec_VkImageCopy2(vkb_dec *d, VkImageCopy2 *s); +void vkb_decfix_VkImageCopy2(vkb_dec *d, VkImageCopy2 *s); +void vkb_enc_VkImageCreateInfo(vkb_enc *e, const VkImageCreateInfo *s); +void vkb_encfix_VkImageCreateInfo(vkb_enc *e, const VkImageCreateInfo *s, size_t raw); +void vkb_dec_VkImageCreateInfo(vkb_dec *d, VkImageCreateInfo *s); +void vkb_decfix_VkImageCreateInfo(vkb_dec *d, VkImageCreateInfo *s); +void vkb_enc_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkb_enc *e, const VkImageDrmFormatModifierExplicitCreateInfoEXT *s); +void vkb_encfix_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkb_enc *e, const VkImageDrmFormatModifierExplicitCreateInfoEXT *s, size_t raw); +void vkb_dec_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkb_dec *d, VkImageDrmFormatModifierExplicitCreateInfoEXT *s); +void vkb_decfix_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkb_dec *d, VkImageDrmFormatModifierExplicitCreateInfoEXT *s); +void vkb_enc_VkImageDrmFormatModifierListCreateInfoEXT(vkb_enc *e, const VkImageDrmFormatModifierListCreateInfoEXT *s); +void vkb_encfix_VkImageDrmFormatModifierListCreateInfoEXT(vkb_enc *e, const VkImageDrmFormatModifierListCreateInfoEXT *s, size_t raw); +void vkb_dec_VkImageDrmFormatModifierListCreateInfoEXT(vkb_dec *d, VkImageDrmFormatModifierListCreateInfoEXT *s); +void vkb_decfix_VkImageDrmFormatModifierListCreateInfoEXT(vkb_dec *d, VkImageDrmFormatModifierListCreateInfoEXT *s); +void vkb_enc_VkImageDrmFormatModifierPropertiesEXT(vkb_enc *e, const VkImageDrmFormatModifierPropertiesEXT *s); +void vkb_encfix_VkImageDrmFormatModifierPropertiesEXT(vkb_enc *e, const VkImageDrmFormatModifierPropertiesEXT *s, size_t raw); +void vkb_dec_VkImageDrmFormatModifierPropertiesEXT(vkb_dec *d, VkImageDrmFormatModifierPropertiesEXT *s); +void vkb_decfix_VkImageDrmFormatModifierPropertiesEXT(vkb_dec *d, VkImageDrmFormatModifierPropertiesEXT *s); +void vkb_enc_VkImageFormatListCreateInfo(vkb_enc *e, const VkImageFormatListCreateInfo *s); +void vkb_encfix_VkImageFormatListCreateInfo(vkb_enc *e, const VkImageFormatListCreateInfo *s, size_t raw); +void vkb_dec_VkImageFormatListCreateInfo(vkb_dec *d, VkImageFormatListCreateInfo *s); +void vkb_decfix_VkImageFormatListCreateInfo(vkb_dec *d, VkImageFormatListCreateInfo *s); +void vkb_enc_VkImageFormatProperties2(vkb_enc *e, const VkImageFormatProperties2 *s); +void vkb_encfix_VkImageFormatProperties2(vkb_enc *e, const VkImageFormatProperties2 *s, size_t raw); +void vkb_dec_VkImageFormatProperties2(vkb_dec *d, VkImageFormatProperties2 *s); +void vkb_decfix_VkImageFormatProperties2(vkb_dec *d, VkImageFormatProperties2 *s); +void vkb_enc_VkImageMemoryBarrier(vkb_enc *e, const VkImageMemoryBarrier *s); +void vkb_encfix_VkImageMemoryBarrier(vkb_enc *e, const VkImageMemoryBarrier *s, size_t raw); +void vkb_dec_VkImageMemoryBarrier(vkb_dec *d, VkImageMemoryBarrier *s); +void vkb_decfix_VkImageMemoryBarrier(vkb_dec *d, VkImageMemoryBarrier *s); +void vkb_enc_VkImageMemoryBarrier2(vkb_enc *e, const VkImageMemoryBarrier2 *s); +void vkb_encfix_VkImageMemoryBarrier2(vkb_enc *e, const VkImageMemoryBarrier2 *s, size_t raw); +void vkb_dec_VkImageMemoryBarrier2(vkb_dec *d, VkImageMemoryBarrier2 *s); +void vkb_decfix_VkImageMemoryBarrier2(vkb_dec *d, VkImageMemoryBarrier2 *s); +void vkb_enc_VkImageMemoryRequirementsInfo2(vkb_enc *e, const VkImageMemoryRequirementsInfo2 *s); +void vkb_encfix_VkImageMemoryRequirementsInfo2(vkb_enc *e, const VkImageMemoryRequirementsInfo2 *s, size_t raw); +void vkb_dec_VkImageMemoryRequirementsInfo2(vkb_dec *d, VkImageMemoryRequirementsInfo2 *s); +void vkb_decfix_VkImageMemoryRequirementsInfo2(vkb_dec *d, VkImageMemoryRequirementsInfo2 *s); +void vkb_enc_VkImagePlaneMemoryRequirementsInfo(vkb_enc *e, const VkImagePlaneMemoryRequirementsInfo *s); +void vkb_encfix_VkImagePlaneMemoryRequirementsInfo(vkb_enc *e, const VkImagePlaneMemoryRequirementsInfo *s, size_t raw); +void vkb_dec_VkImagePlaneMemoryRequirementsInfo(vkb_dec *d, VkImagePlaneMemoryRequirementsInfo *s); +void vkb_decfix_VkImagePlaneMemoryRequirementsInfo(vkb_dec *d, VkImagePlaneMemoryRequirementsInfo *s); +void vkb_enc_VkImageResolve2(vkb_enc *e, const VkImageResolve2 *s); +void vkb_encfix_VkImageResolve2(vkb_enc *e, const VkImageResolve2 *s, size_t raw); +void vkb_dec_VkImageResolve2(vkb_dec *d, VkImageResolve2 *s); +void vkb_decfix_VkImageResolve2(vkb_dec *d, VkImageResolve2 *s); +void vkb_enc_VkImageSparseMemoryRequirementsInfo2(vkb_enc *e, const VkImageSparseMemoryRequirementsInfo2 *s); +void vkb_encfix_VkImageSparseMemoryRequirementsInfo2(vkb_enc *e, const VkImageSparseMemoryRequirementsInfo2 *s, size_t raw); +void vkb_dec_VkImageSparseMemoryRequirementsInfo2(vkb_dec *d, VkImageSparseMemoryRequirementsInfo2 *s); +void vkb_decfix_VkImageSparseMemoryRequirementsInfo2(vkb_dec *d, VkImageSparseMemoryRequirementsInfo2 *s); +void vkb_enc_VkImageStencilUsageCreateInfo(vkb_enc *e, const VkImageStencilUsageCreateInfo *s); +void vkb_encfix_VkImageStencilUsageCreateInfo(vkb_enc *e, const VkImageStencilUsageCreateInfo *s, size_t raw); +void vkb_dec_VkImageStencilUsageCreateInfo(vkb_dec *d, VkImageStencilUsageCreateInfo *s); +void vkb_decfix_VkImageStencilUsageCreateInfo(vkb_dec *d, VkImageStencilUsageCreateInfo *s); +void vkb_enc_VkImageSubresource2EXT(vkb_enc *e, const VkImageSubresource2EXT *s); +void vkb_encfix_VkImageSubresource2EXT(vkb_enc *e, const VkImageSubresource2EXT *s, size_t raw); +void vkb_dec_VkImageSubresource2EXT(vkb_dec *d, VkImageSubresource2EXT *s); +void vkb_decfix_VkImageSubresource2EXT(vkb_dec *d, VkImageSubresource2EXT *s); +void vkb_enc_VkImageSwapchainCreateInfoKHR(vkb_enc *e, const VkImageSwapchainCreateInfoKHR *s); +void vkb_encfix_VkImageSwapchainCreateInfoKHR(vkb_enc *e, const VkImageSwapchainCreateInfoKHR *s, size_t raw); +void vkb_dec_VkImageSwapchainCreateInfoKHR(vkb_dec *d, VkImageSwapchainCreateInfoKHR *s); +void vkb_decfix_VkImageSwapchainCreateInfoKHR(vkb_dec *d, VkImageSwapchainCreateInfoKHR *s); +void vkb_enc_VkImageViewASTCDecodeModeEXT(vkb_enc *e, const VkImageViewASTCDecodeModeEXT *s); +void vkb_encfix_VkImageViewASTCDecodeModeEXT(vkb_enc *e, const VkImageViewASTCDecodeModeEXT *s, size_t raw); +void vkb_dec_VkImageViewASTCDecodeModeEXT(vkb_dec *d, VkImageViewASTCDecodeModeEXT *s); +void vkb_decfix_VkImageViewASTCDecodeModeEXT(vkb_dec *d, VkImageViewASTCDecodeModeEXT *s); +void vkb_enc_VkImageViewCreateInfo(vkb_enc *e, const VkImageViewCreateInfo *s); +void vkb_encfix_VkImageViewCreateInfo(vkb_enc *e, const VkImageViewCreateInfo *s, size_t raw); +void vkb_dec_VkImageViewCreateInfo(vkb_dec *d, VkImageViewCreateInfo *s); +void vkb_decfix_VkImageViewCreateInfo(vkb_dec *d, VkImageViewCreateInfo *s); +void vkb_enc_VkImageViewMinLodCreateInfoEXT(vkb_enc *e, const VkImageViewMinLodCreateInfoEXT *s); +void vkb_encfix_VkImageViewMinLodCreateInfoEXT(vkb_enc *e, const VkImageViewMinLodCreateInfoEXT *s, size_t raw); +void vkb_dec_VkImageViewMinLodCreateInfoEXT(vkb_dec *d, VkImageViewMinLodCreateInfoEXT *s); +void vkb_decfix_VkImageViewMinLodCreateInfoEXT(vkb_dec *d, VkImageViewMinLodCreateInfoEXT *s); +void vkb_enc_VkImageViewSlicedCreateInfoEXT(vkb_enc *e, const VkImageViewSlicedCreateInfoEXT *s); +void vkb_encfix_VkImageViewSlicedCreateInfoEXT(vkb_enc *e, const VkImageViewSlicedCreateInfoEXT *s, size_t raw); +void vkb_dec_VkImageViewSlicedCreateInfoEXT(vkb_dec *d, VkImageViewSlicedCreateInfoEXT *s); +void vkb_decfix_VkImageViewSlicedCreateInfoEXT(vkb_dec *d, VkImageViewSlicedCreateInfoEXT *s); +void vkb_enc_VkImageViewUsageCreateInfo(vkb_enc *e, const VkImageViewUsageCreateInfo *s); +void vkb_encfix_VkImageViewUsageCreateInfo(vkb_enc *e, const VkImageViewUsageCreateInfo *s, size_t raw); +void vkb_dec_VkImageViewUsageCreateInfo(vkb_dec *d, VkImageViewUsageCreateInfo *s); +void vkb_decfix_VkImageViewUsageCreateInfo(vkb_dec *d, VkImageViewUsageCreateInfo *s); +void vkb_enc_VkImportFenceFdInfoKHR(vkb_enc *e, const VkImportFenceFdInfoKHR *s); +void vkb_encfix_VkImportFenceFdInfoKHR(vkb_enc *e, const VkImportFenceFdInfoKHR *s, size_t raw); +void vkb_dec_VkImportFenceFdInfoKHR(vkb_dec *d, VkImportFenceFdInfoKHR *s); +void vkb_decfix_VkImportFenceFdInfoKHR(vkb_dec *d, VkImportFenceFdInfoKHR *s); +void vkb_enc_VkImportMemoryFdInfoKHR(vkb_enc *e, const VkImportMemoryFdInfoKHR *s); +void vkb_encfix_VkImportMemoryFdInfoKHR(vkb_enc *e, const VkImportMemoryFdInfoKHR *s, size_t raw); +void vkb_dec_VkImportMemoryFdInfoKHR(vkb_dec *d, VkImportMemoryFdInfoKHR *s); +void vkb_decfix_VkImportMemoryFdInfoKHR(vkb_dec *d, VkImportMemoryFdInfoKHR *s); +void vkb_enc_VkImportSemaphoreFdInfoKHR(vkb_enc *e, const VkImportSemaphoreFdInfoKHR *s); +void vkb_encfix_VkImportSemaphoreFdInfoKHR(vkb_enc *e, const VkImportSemaphoreFdInfoKHR *s, size_t raw); +void vkb_dec_VkImportSemaphoreFdInfoKHR(vkb_dec *d, VkImportSemaphoreFdInfoKHR *s); +void vkb_decfix_VkImportSemaphoreFdInfoKHR(vkb_dec *d, VkImportSemaphoreFdInfoKHR *s); +void vkb_enc_VkInstanceCreateInfo(vkb_enc *e, const VkInstanceCreateInfo *s); +void vkb_encfix_VkInstanceCreateInfo(vkb_enc *e, const VkInstanceCreateInfo *s, size_t raw); +void vkb_dec_VkInstanceCreateInfo(vkb_dec *d, VkInstanceCreateInfo *s); +void vkb_decfix_VkInstanceCreateInfo(vkb_dec *d, VkInstanceCreateInfo *s); +void vkb_enc_VkMappedMemoryRange(vkb_enc *e, const VkMappedMemoryRange *s); +void vkb_encfix_VkMappedMemoryRange(vkb_enc *e, const VkMappedMemoryRange *s, size_t raw); +void vkb_dec_VkMappedMemoryRange(vkb_dec *d, VkMappedMemoryRange *s); +void vkb_decfix_VkMappedMemoryRange(vkb_dec *d, VkMappedMemoryRange *s); +void vkb_enc_VkMemoryAllocateFlagsInfo(vkb_enc *e, const VkMemoryAllocateFlagsInfo *s); +void vkb_encfix_VkMemoryAllocateFlagsInfo(vkb_enc *e, const VkMemoryAllocateFlagsInfo *s, size_t raw); +void vkb_dec_VkMemoryAllocateFlagsInfo(vkb_dec *d, VkMemoryAllocateFlagsInfo *s); +void vkb_decfix_VkMemoryAllocateFlagsInfo(vkb_dec *d, VkMemoryAllocateFlagsInfo *s); +void vkb_enc_VkMemoryAllocateInfo(vkb_enc *e, const VkMemoryAllocateInfo *s); +void vkb_encfix_VkMemoryAllocateInfo(vkb_enc *e, const VkMemoryAllocateInfo *s, size_t raw); +void vkb_dec_VkMemoryAllocateInfo(vkb_dec *d, VkMemoryAllocateInfo *s); +void vkb_decfix_VkMemoryAllocateInfo(vkb_dec *d, VkMemoryAllocateInfo *s); +void vkb_enc_VkMemoryBarrier(vkb_enc *e, const VkMemoryBarrier *s); +void vkb_encfix_VkMemoryBarrier(vkb_enc *e, const VkMemoryBarrier *s, size_t raw); +void vkb_dec_VkMemoryBarrier(vkb_dec *d, VkMemoryBarrier *s); +void vkb_decfix_VkMemoryBarrier(vkb_dec *d, VkMemoryBarrier *s); +void vkb_enc_VkMemoryBarrier2(vkb_enc *e, const VkMemoryBarrier2 *s); +void vkb_encfix_VkMemoryBarrier2(vkb_enc *e, const VkMemoryBarrier2 *s, size_t raw); +void vkb_dec_VkMemoryBarrier2(vkb_dec *d, VkMemoryBarrier2 *s); +void vkb_decfix_VkMemoryBarrier2(vkb_dec *d, VkMemoryBarrier2 *s); +void vkb_enc_VkMemoryDedicatedAllocateInfo(vkb_enc *e, const VkMemoryDedicatedAllocateInfo *s); +void vkb_encfix_VkMemoryDedicatedAllocateInfo(vkb_enc *e, const VkMemoryDedicatedAllocateInfo *s, size_t raw); +void vkb_dec_VkMemoryDedicatedAllocateInfo(vkb_dec *d, VkMemoryDedicatedAllocateInfo *s); +void vkb_decfix_VkMemoryDedicatedAllocateInfo(vkb_dec *d, VkMemoryDedicatedAllocateInfo *s); +void vkb_enc_VkMemoryDedicatedRequirements(vkb_enc *e, const VkMemoryDedicatedRequirements *s); +void vkb_encfix_VkMemoryDedicatedRequirements(vkb_enc *e, const VkMemoryDedicatedRequirements *s, size_t raw); +void vkb_dec_VkMemoryDedicatedRequirements(vkb_dec *d, VkMemoryDedicatedRequirements *s); +void vkb_decfix_VkMemoryDedicatedRequirements(vkb_dec *d, VkMemoryDedicatedRequirements *s); +void vkb_enc_VkMemoryFdPropertiesKHR(vkb_enc *e, const VkMemoryFdPropertiesKHR *s); +void vkb_encfix_VkMemoryFdPropertiesKHR(vkb_enc *e, const VkMemoryFdPropertiesKHR *s, size_t raw); +void vkb_dec_VkMemoryFdPropertiesKHR(vkb_dec *d, VkMemoryFdPropertiesKHR *s); +void vkb_decfix_VkMemoryFdPropertiesKHR(vkb_dec *d, VkMemoryFdPropertiesKHR *s); +void vkb_enc_VkMemoryGetFdInfoKHR(vkb_enc *e, const VkMemoryGetFdInfoKHR *s); +void vkb_encfix_VkMemoryGetFdInfoKHR(vkb_enc *e, const VkMemoryGetFdInfoKHR *s, size_t raw); +void vkb_dec_VkMemoryGetFdInfoKHR(vkb_dec *d, VkMemoryGetFdInfoKHR *s); +void vkb_decfix_VkMemoryGetFdInfoKHR(vkb_dec *d, VkMemoryGetFdInfoKHR *s); +void vkb_enc_VkMemoryOpaqueCaptureAddressAllocateInfo(vkb_enc *e, const VkMemoryOpaqueCaptureAddressAllocateInfo *s); +void vkb_encfix_VkMemoryOpaqueCaptureAddressAllocateInfo(vkb_enc *e, const VkMemoryOpaqueCaptureAddressAllocateInfo *s, size_t raw); +void vkb_dec_VkMemoryOpaqueCaptureAddressAllocateInfo(vkb_dec *d, VkMemoryOpaqueCaptureAddressAllocateInfo *s); +void vkb_decfix_VkMemoryOpaqueCaptureAddressAllocateInfo(vkb_dec *d, VkMemoryOpaqueCaptureAddressAllocateInfo *s); +void vkb_enc_VkMemoryPriorityAllocateInfoEXT(vkb_enc *e, const VkMemoryPriorityAllocateInfoEXT *s); +void vkb_encfix_VkMemoryPriorityAllocateInfoEXT(vkb_enc *e, const VkMemoryPriorityAllocateInfoEXT *s, size_t raw); +void vkb_dec_VkMemoryPriorityAllocateInfoEXT(vkb_dec *d, VkMemoryPriorityAllocateInfoEXT *s); +void vkb_decfix_VkMemoryPriorityAllocateInfoEXT(vkb_dec *d, VkMemoryPriorityAllocateInfoEXT *s); +void vkb_enc_VkMemoryRequirements2(vkb_enc *e, const VkMemoryRequirements2 *s); +void vkb_encfix_VkMemoryRequirements2(vkb_enc *e, const VkMemoryRequirements2 *s, size_t raw); +void vkb_dec_VkMemoryRequirements2(vkb_dec *d, VkMemoryRequirements2 *s); +void vkb_decfix_VkMemoryRequirements2(vkb_dec *d, VkMemoryRequirements2 *s); +void vkb_enc_VkMultisamplePropertiesEXT(vkb_enc *e, const VkMultisamplePropertiesEXT *s); +void vkb_encfix_VkMultisamplePropertiesEXT(vkb_enc *e, const VkMultisamplePropertiesEXT *s, size_t raw); +void vkb_dec_VkMultisamplePropertiesEXT(vkb_dec *d, VkMultisamplePropertiesEXT *s); +void vkb_decfix_VkMultisamplePropertiesEXT(vkb_dec *d, VkMultisamplePropertiesEXT *s); +void vkb_enc_VkMultisampledRenderToSingleSampledInfoEXT(vkb_enc *e, const VkMultisampledRenderToSingleSampledInfoEXT *s); +void vkb_encfix_VkMultisampledRenderToSingleSampledInfoEXT(vkb_enc *e, const VkMultisampledRenderToSingleSampledInfoEXT *s, size_t raw); +void vkb_dec_VkMultisampledRenderToSingleSampledInfoEXT(vkb_dec *d, VkMultisampledRenderToSingleSampledInfoEXT *s); +void vkb_decfix_VkMultisampledRenderToSingleSampledInfoEXT(vkb_dec *d, VkMultisampledRenderToSingleSampledInfoEXT *s); +void vkb_enc_VkMutableDescriptorTypeCreateInfoEXT(vkb_enc *e, const VkMutableDescriptorTypeCreateInfoEXT *s); +void vkb_encfix_VkMutableDescriptorTypeCreateInfoEXT(vkb_enc *e, const VkMutableDescriptorTypeCreateInfoEXT *s, size_t raw); +void vkb_dec_VkMutableDescriptorTypeCreateInfoEXT(vkb_dec *d, VkMutableDescriptorTypeCreateInfoEXT *s); +void vkb_decfix_VkMutableDescriptorTypeCreateInfoEXT(vkb_dec *d, VkMutableDescriptorTypeCreateInfoEXT *s); +void vkb_enc_VkMutableDescriptorTypeListEXT(vkb_enc *e, const VkMutableDescriptorTypeListEXT *s); +void vkb_encfix_VkMutableDescriptorTypeListEXT(vkb_enc *e, const VkMutableDescriptorTypeListEXT *s, size_t raw); +void vkb_dec_VkMutableDescriptorTypeListEXT(vkb_dec *d, VkMutableDescriptorTypeListEXT *s); +void vkb_decfix_VkMutableDescriptorTypeListEXT(vkb_dec *d, VkMutableDescriptorTypeListEXT *s); +void vkb_enc_VkPhysicalDevice16BitStorageFeatures(vkb_enc *e, const VkPhysicalDevice16BitStorageFeatures *s); +void vkb_encfix_VkPhysicalDevice16BitStorageFeatures(vkb_enc *e, const VkPhysicalDevice16BitStorageFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDevice16BitStorageFeatures(vkb_dec *d, VkPhysicalDevice16BitStorageFeatures *s); +void vkb_decfix_VkPhysicalDevice16BitStorageFeatures(vkb_dec *d, VkPhysicalDevice16BitStorageFeatures *s); +void vkb_enc_VkPhysicalDevice4444FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDevice4444FormatsFeaturesEXT *s); +void vkb_encfix_VkPhysicalDevice4444FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDevice4444FormatsFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDevice4444FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDevice4444FormatsFeaturesEXT *s); +void vkb_decfix_VkPhysicalDevice4444FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDevice4444FormatsFeaturesEXT *s); +void vkb_enc_VkPhysicalDevice8BitStorageFeatures(vkb_enc *e, const VkPhysicalDevice8BitStorageFeatures *s); +void vkb_encfix_VkPhysicalDevice8BitStorageFeatures(vkb_enc *e, const VkPhysicalDevice8BitStorageFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDevice8BitStorageFeatures(vkb_dec *d, VkPhysicalDevice8BitStorageFeatures *s); +void vkb_decfix_VkPhysicalDevice8BitStorageFeatures(vkb_dec *d, VkPhysicalDevice8BitStorageFeatures *s); +void vkb_enc_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceASTCDecodeFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceASTCDecodeFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkb_dec *d, VkPhysicalDeviceASTCDecodeFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkb_dec *d, VkPhysicalDeviceASTCDecodeFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(vkb_dec *d, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(vkb_dec *d, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkb_dec *d, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkb_dec *d, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceBufferDeviceAddressFeatures(vkb_enc *e, const VkPhysicalDeviceBufferDeviceAddressFeatures *s); +void vkb_encfix_VkPhysicalDeviceBufferDeviceAddressFeatures(vkb_enc *e, const VkPhysicalDeviceBufferDeviceAddressFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceBufferDeviceAddressFeatures(vkb_dec *d, VkPhysicalDeviceBufferDeviceAddressFeatures *s); +void vkb_decfix_VkPhysicalDeviceBufferDeviceAddressFeatures(vkb_dec *d, VkPhysicalDeviceBufferDeviceAddressFeatures *s); +void vkb_enc_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceColorWriteEnableFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceColorWriteEnableFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceColorWriteEnableFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceColorWriteEnableFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceColorWriteEnableFeaturesEXT(vkb_dec *d, VkPhysicalDeviceColorWriteEnableFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceColorWriteEnableFeaturesEXT(vkb_dec *d, VkPhysicalDeviceColorWriteEnableFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkb_dec *d, VkPhysicalDeviceConditionalRenderingFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkb_dec *d, VkPhysicalDeviceConditionalRenderingFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkb_dec *d, VkPhysicalDeviceConservativeRasterizationPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkb_dec *d, VkPhysicalDeviceConservativeRasterizationPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkb_dec *d, VkPhysicalDeviceCustomBorderColorFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkb_dec *d, VkPhysicalDeviceCustomBorderColorFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceCustomBorderColorPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceCustomBorderColorPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkb_dec *d, VkPhysicalDeviceCustomBorderColorPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkb_dec *d, VkPhysicalDeviceCustomBorderColorPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceDepthClipControlFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClipControlFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceDepthClipControlFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClipControlFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceDepthClipControlFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClipControlFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceDepthClipControlFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClipControlFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceDepthClipEnableFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceDepthClipEnableFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceDepthClipEnableFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClipEnableFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceDepthClipEnableFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClipEnableFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceDepthStencilResolveProperties(vkb_enc *e, const VkPhysicalDeviceDepthStencilResolveProperties *s); +void vkb_encfix_VkPhysicalDeviceDepthStencilResolveProperties(vkb_enc *e, const VkPhysicalDeviceDepthStencilResolveProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceDepthStencilResolveProperties(vkb_dec *d, VkPhysicalDeviceDepthStencilResolveProperties *s); +void vkb_decfix_VkPhysicalDeviceDepthStencilResolveProperties(vkb_dec *d, VkPhysicalDeviceDepthStencilResolveProperties *s); +void vkb_enc_VkPhysicalDeviceDescriptorIndexingFeatures(vkb_enc *e, const VkPhysicalDeviceDescriptorIndexingFeatures *s); +void vkb_encfix_VkPhysicalDeviceDescriptorIndexingFeatures(vkb_enc *e, const VkPhysicalDeviceDescriptorIndexingFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceDescriptorIndexingFeatures(vkb_dec *d, VkPhysicalDeviceDescriptorIndexingFeatures *s); +void vkb_decfix_VkPhysicalDeviceDescriptorIndexingFeatures(vkb_dec *d, VkPhysicalDeviceDescriptorIndexingFeatures *s); +void vkb_enc_VkPhysicalDeviceDescriptorIndexingProperties(vkb_enc *e, const VkPhysicalDeviceDescriptorIndexingProperties *s); +void vkb_encfix_VkPhysicalDeviceDescriptorIndexingProperties(vkb_enc *e, const VkPhysicalDeviceDescriptorIndexingProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceDescriptorIndexingProperties(vkb_dec *d, VkPhysicalDeviceDescriptorIndexingProperties *s); +void vkb_decfix_VkPhysicalDeviceDescriptorIndexingProperties(vkb_dec *d, VkPhysicalDeviceDescriptorIndexingProperties *s); +void vkb_enc_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkb_enc *e, const VkPhysicalDeviceDiscardRectanglePropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkb_enc *e, const VkPhysicalDeviceDiscardRectanglePropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkb_dec *d, VkPhysicalDeviceDiscardRectanglePropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkb_dec *d, VkPhysicalDeviceDiscardRectanglePropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceDriverProperties(vkb_enc *e, const VkPhysicalDeviceDriverProperties *s); +void vkb_encfix_VkPhysicalDeviceDriverProperties(vkb_enc *e, const VkPhysicalDeviceDriverProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceDriverProperties(vkb_dec *d, VkPhysicalDeviceDriverProperties *s); +void vkb_decfix_VkPhysicalDeviceDriverProperties(vkb_dec *d, VkPhysicalDeviceDriverProperties *s); +void vkb_enc_VkPhysicalDeviceDrmPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceDrmPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceDrmPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceDrmPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceDrmPropertiesEXT(vkb_dec *d, VkPhysicalDeviceDrmPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceDrmPropertiesEXT(vkb_dec *d, VkPhysicalDeviceDrmPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceDynamicRenderingFeatures(vkb_enc *e, const VkPhysicalDeviceDynamicRenderingFeatures *s); +void vkb_encfix_VkPhysicalDeviceDynamicRenderingFeatures(vkb_enc *e, const VkPhysicalDeviceDynamicRenderingFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceDynamicRenderingFeatures(vkb_dec *d, VkPhysicalDeviceDynamicRenderingFeatures *s); +void vkb_decfix_VkPhysicalDeviceDynamicRenderingFeatures(vkb_dec *d, VkPhysicalDeviceDynamicRenderingFeatures *s); +void vkb_enc_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceExternalBufferInfo(vkb_enc *e, const VkPhysicalDeviceExternalBufferInfo *s); +void vkb_encfix_VkPhysicalDeviceExternalBufferInfo(vkb_enc *e, const VkPhysicalDeviceExternalBufferInfo *s, size_t raw); +void vkb_dec_VkPhysicalDeviceExternalBufferInfo(vkb_dec *d, VkPhysicalDeviceExternalBufferInfo *s); +void vkb_decfix_VkPhysicalDeviceExternalBufferInfo(vkb_dec *d, VkPhysicalDeviceExternalBufferInfo *s); +void vkb_enc_VkPhysicalDeviceExternalFenceInfo(vkb_enc *e, const VkPhysicalDeviceExternalFenceInfo *s); +void vkb_encfix_VkPhysicalDeviceExternalFenceInfo(vkb_enc *e, const VkPhysicalDeviceExternalFenceInfo *s, size_t raw); +void vkb_dec_VkPhysicalDeviceExternalFenceInfo(vkb_dec *d, VkPhysicalDeviceExternalFenceInfo *s); +void vkb_decfix_VkPhysicalDeviceExternalFenceInfo(vkb_dec *d, VkPhysicalDeviceExternalFenceInfo *s); +void vkb_enc_VkPhysicalDeviceExternalImageFormatInfo(vkb_enc *e, const VkPhysicalDeviceExternalImageFormatInfo *s); +void vkb_encfix_VkPhysicalDeviceExternalImageFormatInfo(vkb_enc *e, const VkPhysicalDeviceExternalImageFormatInfo *s, size_t raw); +void vkb_dec_VkPhysicalDeviceExternalImageFormatInfo(vkb_dec *d, VkPhysicalDeviceExternalImageFormatInfo *s); +void vkb_decfix_VkPhysicalDeviceExternalImageFormatInfo(vkb_dec *d, VkPhysicalDeviceExternalImageFormatInfo *s); +void vkb_enc_VkPhysicalDeviceExternalSemaphoreInfo(vkb_enc *e, const VkPhysicalDeviceExternalSemaphoreInfo *s); +void vkb_encfix_VkPhysicalDeviceExternalSemaphoreInfo(vkb_enc *e, const VkPhysicalDeviceExternalSemaphoreInfo *s, size_t raw); +void vkb_dec_VkPhysicalDeviceExternalSemaphoreInfo(vkb_dec *d, VkPhysicalDeviceExternalSemaphoreInfo *s); +void vkb_decfix_VkPhysicalDeviceExternalSemaphoreInfo(vkb_dec *d, VkPhysicalDeviceExternalSemaphoreInfo *s); +void vkb_enc_VkPhysicalDeviceFeatures2(vkb_enc *e, const VkPhysicalDeviceFeatures2 *s); +void vkb_encfix_VkPhysicalDeviceFeatures2(vkb_enc *e, const VkPhysicalDeviceFeatures2 *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFeatures2(vkb_dec *d, VkPhysicalDeviceFeatures2 *s); +void vkb_decfix_VkPhysicalDeviceFeatures2(vkb_dec *d, VkPhysicalDeviceFeatures2 *s); +void vkb_enc_VkPhysicalDeviceFloatControlsProperties(vkb_enc *e, const VkPhysicalDeviceFloatControlsProperties *s); +void vkb_encfix_VkPhysicalDeviceFloatControlsProperties(vkb_enc *e, const VkPhysicalDeviceFloatControlsProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFloatControlsProperties(vkb_dec *d, VkPhysicalDeviceFloatControlsProperties *s); +void vkb_decfix_VkPhysicalDeviceFloatControlsProperties(vkb_dec *d, VkPhysicalDeviceFloatControlsProperties *s); +void vkb_enc_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMapFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMapFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMapPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMapPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *s); +void vkb_encfix_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *s); +void vkb_decfix_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *s); +void vkb_enc_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *s); +void vkb_encfix_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *s); +void vkb_decfix_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *s); +void vkb_enc_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *s); +void vkb_encfix_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRateFeaturesKHR *s); +void vkb_decfix_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRateFeaturesKHR *s); +void vkb_enc_VkPhysicalDeviceFragmentShadingRateKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRateKHR *s); +void vkb_encfix_VkPhysicalDeviceFragmentShadingRateKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRateKHR *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFragmentShadingRateKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRateKHR *s); +void vkb_decfix_VkPhysicalDeviceFragmentShadingRateKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRateKHR *s); +void vkb_enc_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *s); +void vkb_encfix_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *s, size_t raw); +void vkb_dec_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRatePropertiesKHR *s); +void vkb_decfix_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRatePropertiesKHR *s); +void vkb_enc_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *s); +void vkb_encfix_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *s, size_t raw); +void vkb_dec_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(vkb_dec *d, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *s); +void vkb_decfix_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(vkb_dec *d, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *s); +void vkb_enc_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(vkb_dec *d, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(vkb_dec *d, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(vkb_dec *d, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(vkb_dec *d, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceGroupProperties(vkb_enc *e, const VkPhysicalDeviceGroupProperties *s); +void vkb_encfix_VkPhysicalDeviceGroupProperties(vkb_enc *e, const VkPhysicalDeviceGroupProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceGroupProperties(vkb_dec *d, VkPhysicalDeviceGroupProperties *s); +void vkb_decfix_VkPhysicalDeviceGroupProperties(vkb_dec *d, VkPhysicalDeviceGroupProperties *s); +void vkb_enc_VkPhysicalDeviceHostQueryResetFeatures(vkb_enc *e, const VkPhysicalDeviceHostQueryResetFeatures *s); +void vkb_encfix_VkPhysicalDeviceHostQueryResetFeatures(vkb_enc *e, const VkPhysicalDeviceHostQueryResetFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceHostQueryResetFeatures(vkb_dec *d, VkPhysicalDeviceHostQueryResetFeatures *s); +void vkb_decfix_VkPhysicalDeviceHostQueryResetFeatures(vkb_dec *d, VkPhysicalDeviceHostQueryResetFeatures *s); +void vkb_enc_VkPhysicalDeviceIDProperties(vkb_enc *e, const VkPhysicalDeviceIDProperties *s); +void vkb_encfix_VkPhysicalDeviceIDProperties(vkb_enc *e, const VkPhysicalDeviceIDProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceIDProperties(vkb_dec *d, VkPhysicalDeviceIDProperties *s); +void vkb_decfix_VkPhysicalDeviceIDProperties(vkb_dec *d, VkPhysicalDeviceIDProperties *s); +void vkb_enc_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceImageCompressionControlFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageCompressionControlFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceImageCompressionControlFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageCompressionControlFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceImageCompressionControlFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageCompressionControlFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceImageCompressionControlFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageCompressionControlFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(vkb_enc *e, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *s); +void vkb_encfix_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(vkb_enc *e, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(vkb_dec *d, VkPhysicalDeviceImageDrmFormatModifierInfoEXT *s); +void vkb_decfix_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(vkb_dec *d, VkPhysicalDeviceImageDrmFormatModifierInfoEXT *s); +void vkb_enc_VkPhysicalDeviceImageFormatInfo2(vkb_enc *e, const VkPhysicalDeviceImageFormatInfo2 *s); +void vkb_encfix_VkPhysicalDeviceImageFormatInfo2(vkb_enc *e, const VkPhysicalDeviceImageFormatInfo2 *s, size_t raw); +void vkb_dec_VkPhysicalDeviceImageFormatInfo2(vkb_dec *d, VkPhysicalDeviceImageFormatInfo2 *s); +void vkb_decfix_VkPhysicalDeviceImageFormatInfo2(vkb_dec *d, VkPhysicalDeviceImageFormatInfo2 *s); +void vkb_enc_VkPhysicalDeviceImageRobustnessFeatures(vkb_enc *e, const VkPhysicalDeviceImageRobustnessFeatures *s); +void vkb_encfix_VkPhysicalDeviceImageRobustnessFeatures(vkb_enc *e, const VkPhysicalDeviceImageRobustnessFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceImageRobustnessFeatures(vkb_dec *d, VkPhysicalDeviceImageRobustnessFeatures *s); +void vkb_decfix_VkPhysicalDeviceImageRobustnessFeatures(vkb_dec *d, VkPhysicalDeviceImageRobustnessFeatures *s); +void vkb_enc_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceImageViewImageFormatInfoEXT(vkb_enc *e, const VkPhysicalDeviceImageViewImageFormatInfoEXT *s); +void vkb_encfix_VkPhysicalDeviceImageViewImageFormatInfoEXT(vkb_enc *e, const VkPhysicalDeviceImageViewImageFormatInfoEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceImageViewImageFormatInfoEXT(vkb_dec *d, VkPhysicalDeviceImageViewImageFormatInfoEXT *s); +void vkb_decfix_VkPhysicalDeviceImageViewImageFormatInfoEXT(vkb_dec *d, VkPhysicalDeviceImageViewImageFormatInfoEXT *s); +void vkb_enc_VkPhysicalDeviceImageViewMinLodFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceImageViewMinLodFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceImageViewMinLodFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageViewMinLodFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceImageViewMinLodFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageViewMinLodFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceImagelessFramebufferFeatures(vkb_enc *e, const VkPhysicalDeviceImagelessFramebufferFeatures *s); +void vkb_encfix_VkPhysicalDeviceImagelessFramebufferFeatures(vkb_enc *e, const VkPhysicalDeviceImagelessFramebufferFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceImagelessFramebufferFeatures(vkb_dec *d, VkPhysicalDeviceImagelessFramebufferFeatures *s); +void vkb_decfix_VkPhysicalDeviceImagelessFramebufferFeatures(vkb_dec *d, VkPhysicalDeviceImagelessFramebufferFeatures *s); +void vkb_enc_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(vkb_dec *d, VkPhysicalDeviceIndexTypeUint8FeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(vkb_dec *d, VkPhysicalDeviceIndexTypeUint8FeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceInlineUniformBlockFeatures(vkb_enc *e, const VkPhysicalDeviceInlineUniformBlockFeatures *s); +void vkb_encfix_VkPhysicalDeviceInlineUniformBlockFeatures(vkb_enc *e, const VkPhysicalDeviceInlineUniformBlockFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceInlineUniformBlockFeatures(vkb_dec *d, VkPhysicalDeviceInlineUniformBlockFeatures *s); +void vkb_decfix_VkPhysicalDeviceInlineUniformBlockFeatures(vkb_dec *d, VkPhysicalDeviceInlineUniformBlockFeatures *s); +void vkb_enc_VkPhysicalDeviceInlineUniformBlockProperties(vkb_enc *e, const VkPhysicalDeviceInlineUniformBlockProperties *s); +void vkb_encfix_VkPhysicalDeviceInlineUniformBlockProperties(vkb_enc *e, const VkPhysicalDeviceInlineUniformBlockProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceInlineUniformBlockProperties(vkb_dec *d, VkPhysicalDeviceInlineUniformBlockProperties *s); +void vkb_decfix_VkPhysicalDeviceInlineUniformBlockProperties(vkb_dec *d, VkPhysicalDeviceInlineUniformBlockProperties *s); +void vkb_enc_VkPhysicalDeviceLegacyDitheringFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceLegacyDitheringFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceLegacyDitheringFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceLegacyDitheringFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceLegacyDitheringFeaturesEXT(vkb_dec *d, VkPhysicalDeviceLegacyDitheringFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceLegacyDitheringFeaturesEXT(vkb_dec *d, VkPhysicalDeviceLegacyDitheringFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceLineRasterizationFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceLineRasterizationFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkb_dec *d, VkPhysicalDeviceLineRasterizationFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkb_dec *d, VkPhysicalDeviceLineRasterizationFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceLineRasterizationPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceLineRasterizationPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkb_dec *d, VkPhysicalDeviceLineRasterizationPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkb_dec *d, VkPhysicalDeviceLineRasterizationPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceMaintenance3Properties(vkb_enc *e, const VkPhysicalDeviceMaintenance3Properties *s); +void vkb_encfix_VkPhysicalDeviceMaintenance3Properties(vkb_enc *e, const VkPhysicalDeviceMaintenance3Properties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMaintenance3Properties(vkb_dec *d, VkPhysicalDeviceMaintenance3Properties *s); +void vkb_decfix_VkPhysicalDeviceMaintenance3Properties(vkb_dec *d, VkPhysicalDeviceMaintenance3Properties *s); +void vkb_enc_VkPhysicalDeviceMaintenance4Features(vkb_enc *e, const VkPhysicalDeviceMaintenance4Features *s); +void vkb_encfix_VkPhysicalDeviceMaintenance4Features(vkb_enc *e, const VkPhysicalDeviceMaintenance4Features *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMaintenance4Features(vkb_dec *d, VkPhysicalDeviceMaintenance4Features *s); +void vkb_decfix_VkPhysicalDeviceMaintenance4Features(vkb_dec *d, VkPhysicalDeviceMaintenance4Features *s); +void vkb_enc_VkPhysicalDeviceMaintenance4Properties(vkb_enc *e, const VkPhysicalDeviceMaintenance4Properties *s); +void vkb_encfix_VkPhysicalDeviceMaintenance4Properties(vkb_enc *e, const VkPhysicalDeviceMaintenance4Properties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMaintenance4Properties(vkb_dec *d, VkPhysicalDeviceMaintenance4Properties *s); +void vkb_decfix_VkPhysicalDeviceMaintenance4Properties(vkb_dec *d, VkPhysicalDeviceMaintenance4Properties *s); +void vkb_enc_VkPhysicalDeviceMemoryBudgetPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceMemoryBudgetPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceMemoryBudgetPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceMemoryBudgetPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMemoryBudgetPropertiesEXT(vkb_dec *d, VkPhysicalDeviceMemoryBudgetPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceMemoryBudgetPropertiesEXT(vkb_dec *d, VkPhysicalDeviceMemoryBudgetPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMemoryPriorityFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMemoryPriorityFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMemoryPriorityFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMemoryPriorityFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceMemoryProperties2(vkb_enc *e, const VkPhysicalDeviceMemoryProperties2 *s); +void vkb_encfix_VkPhysicalDeviceMemoryProperties2(vkb_enc *e, const VkPhysicalDeviceMemoryProperties2 *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMemoryProperties2(vkb_dec *d, VkPhysicalDeviceMemoryProperties2 *s); +void vkb_decfix_VkPhysicalDeviceMemoryProperties2(vkb_dec *d, VkPhysicalDeviceMemoryProperties2 *s); +void vkb_enc_VkPhysicalDeviceMultiDrawFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMultiDrawFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceMultiDrawFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMultiDrawFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMultiDrawFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMultiDrawFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceMultiDrawFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMultiDrawFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceMultiDrawPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceMultiDrawPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceMultiDrawPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceMultiDrawPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMultiDrawPropertiesEXT(vkb_dec *d, VkPhysicalDeviceMultiDrawPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceMultiDrawPropertiesEXT(vkb_dec *d, VkPhysicalDeviceMultiDrawPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceMultiviewFeatures(vkb_enc *e, const VkPhysicalDeviceMultiviewFeatures *s); +void vkb_encfix_VkPhysicalDeviceMultiviewFeatures(vkb_enc *e, const VkPhysicalDeviceMultiviewFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMultiviewFeatures(vkb_dec *d, VkPhysicalDeviceMultiviewFeatures *s); +void vkb_decfix_VkPhysicalDeviceMultiviewFeatures(vkb_dec *d, VkPhysicalDeviceMultiviewFeatures *s); +void vkb_enc_VkPhysicalDeviceMultiviewProperties(vkb_enc *e, const VkPhysicalDeviceMultiviewProperties *s); +void vkb_encfix_VkPhysicalDeviceMultiviewProperties(vkb_enc *e, const VkPhysicalDeviceMultiviewProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMultiviewProperties(vkb_dec *d, VkPhysicalDeviceMultiviewProperties *s); +void vkb_decfix_VkPhysicalDeviceMultiviewProperties(vkb_dec *d, VkPhysicalDeviceMultiviewProperties *s); +void vkb_enc_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(vkb_dec *d, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(vkb_dec *d, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *s); +void vkb_enc_VkPhysicalDevicePCIBusInfoPropertiesEXT(vkb_enc *e, const VkPhysicalDevicePCIBusInfoPropertiesEXT *s); +void vkb_encfix_VkPhysicalDevicePCIBusInfoPropertiesEXT(vkb_enc *e, const VkPhysicalDevicePCIBusInfoPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDevicePCIBusInfoPropertiesEXT(vkb_dec *d, VkPhysicalDevicePCIBusInfoPropertiesEXT *s); +void vkb_decfix_VkPhysicalDevicePCIBusInfoPropertiesEXT(vkb_dec *d, VkPhysicalDevicePCIBusInfoPropertiesEXT *s); +void vkb_enc_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *s); +void vkb_encfix_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(vkb_dec *d, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *s); +void vkb_decfix_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(vkb_dec *d, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *s); +void vkb_enc_VkPhysicalDevicePipelineCreationCacheControlFeatures(vkb_enc *e, const VkPhysicalDevicePipelineCreationCacheControlFeatures *s); +void vkb_encfix_VkPhysicalDevicePipelineCreationCacheControlFeatures(vkb_enc *e, const VkPhysicalDevicePipelineCreationCacheControlFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDevicePipelineCreationCacheControlFeatures(vkb_dec *d, VkPhysicalDevicePipelineCreationCacheControlFeatures *s); +void vkb_decfix_VkPhysicalDevicePipelineCreationCacheControlFeatures(vkb_dec *d, VkPhysicalDevicePipelineCreationCacheControlFeatures *s); +void vkb_enc_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *s); +void vkb_encfix_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(vkb_dec *d, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *s); +void vkb_decfix_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(vkb_dec *d, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *s); +void vkb_enc_VkPhysicalDevicePipelineRobustnessFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePipelineRobustnessFeaturesEXT *s); +void vkb_encfix_VkPhysicalDevicePipelineRobustnessFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePipelineRobustnessFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDevicePipelineRobustnessFeaturesEXT(vkb_dec *d, VkPhysicalDevicePipelineRobustnessFeaturesEXT *s); +void vkb_decfix_VkPhysicalDevicePipelineRobustnessFeaturesEXT(vkb_dec *d, VkPhysicalDevicePipelineRobustnessFeaturesEXT *s); +void vkb_enc_VkPhysicalDevicePipelineRobustnessPropertiesEXT(vkb_enc *e, const VkPhysicalDevicePipelineRobustnessPropertiesEXT *s); +void vkb_encfix_VkPhysicalDevicePipelineRobustnessPropertiesEXT(vkb_enc *e, const VkPhysicalDevicePipelineRobustnessPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDevicePipelineRobustnessPropertiesEXT(vkb_dec *d, VkPhysicalDevicePipelineRobustnessPropertiesEXT *s); +void vkb_decfix_VkPhysicalDevicePipelineRobustnessPropertiesEXT(vkb_dec *d, VkPhysicalDevicePipelineRobustnessPropertiesEXT *s); +void vkb_enc_VkPhysicalDevicePointClippingProperties(vkb_enc *e, const VkPhysicalDevicePointClippingProperties *s); +void vkb_encfix_VkPhysicalDevicePointClippingProperties(vkb_enc *e, const VkPhysicalDevicePointClippingProperties *s, size_t raw); +void vkb_dec_VkPhysicalDevicePointClippingProperties(vkb_dec *d, VkPhysicalDevicePointClippingProperties *s); +void vkb_decfix_VkPhysicalDevicePointClippingProperties(vkb_dec *d, VkPhysicalDevicePointClippingProperties *s); +void vkb_enc_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *s); +void vkb_encfix_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(vkb_dec *d, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *s); +void vkb_decfix_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(vkb_dec *d, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *s); +void vkb_enc_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *s); +void vkb_encfix_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(vkb_dec *d, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *s); +void vkb_decfix_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(vkb_dec *d, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *s); +void vkb_enc_VkPhysicalDevicePrivateDataFeatures(vkb_enc *e, const VkPhysicalDevicePrivateDataFeatures *s); +void vkb_encfix_VkPhysicalDevicePrivateDataFeatures(vkb_enc *e, const VkPhysicalDevicePrivateDataFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDevicePrivateDataFeatures(vkb_dec *d, VkPhysicalDevicePrivateDataFeatures *s); +void vkb_decfix_VkPhysicalDevicePrivateDataFeatures(vkb_dec *d, VkPhysicalDevicePrivateDataFeatures *s); +void vkb_enc_VkPhysicalDeviceProperties2(vkb_enc *e, const VkPhysicalDeviceProperties2 *s); +void vkb_encfix_VkPhysicalDeviceProperties2(vkb_enc *e, const VkPhysicalDeviceProperties2 *s, size_t raw); +void vkb_dec_VkPhysicalDeviceProperties2(vkb_dec *d, VkPhysicalDeviceProperties2 *s); +void vkb_decfix_VkPhysicalDeviceProperties2(vkb_dec *d, VkPhysicalDeviceProperties2 *s); +void vkb_enc_VkPhysicalDeviceProtectedMemoryFeatures(vkb_enc *e, const VkPhysicalDeviceProtectedMemoryFeatures *s); +void vkb_encfix_VkPhysicalDeviceProtectedMemoryFeatures(vkb_enc *e, const VkPhysicalDeviceProtectedMemoryFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceProtectedMemoryFeatures(vkb_dec *d, VkPhysicalDeviceProtectedMemoryFeatures *s); +void vkb_decfix_VkPhysicalDeviceProtectedMemoryFeatures(vkb_dec *d, VkPhysicalDeviceProtectedMemoryFeatures *s); +void vkb_enc_VkPhysicalDeviceProtectedMemoryProperties(vkb_enc *e, const VkPhysicalDeviceProtectedMemoryProperties *s); +void vkb_encfix_VkPhysicalDeviceProtectedMemoryProperties(vkb_enc *e, const VkPhysicalDeviceProtectedMemoryProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceProtectedMemoryProperties(vkb_dec *d, VkPhysicalDeviceProtectedMemoryProperties *s); +void vkb_decfix_VkPhysicalDeviceProtectedMemoryProperties(vkb_dec *d, VkPhysicalDeviceProtectedMemoryProperties *s); +void vkb_enc_VkPhysicalDeviceProvokingVertexFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceProvokingVertexFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceProvokingVertexFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceProvokingVertexFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceProvokingVertexFeaturesEXT(vkb_dec *d, VkPhysicalDeviceProvokingVertexFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceProvokingVertexFeaturesEXT(vkb_dec *d, VkPhysicalDeviceProvokingVertexFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceProvokingVertexPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceProvokingVertexPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceProvokingVertexPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceProvokingVertexPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceProvokingVertexPropertiesEXT(vkb_dec *d, VkPhysicalDeviceProvokingVertexPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceProvokingVertexPropertiesEXT(vkb_dec *d, VkPhysicalDeviceProvokingVertexPropertiesEXT *s); +void vkb_enc_VkPhysicalDevicePushDescriptorPropertiesKHR(vkb_enc *e, const VkPhysicalDevicePushDescriptorPropertiesKHR *s); +void vkb_encfix_VkPhysicalDevicePushDescriptorPropertiesKHR(vkb_enc *e, const VkPhysicalDevicePushDescriptorPropertiesKHR *s, size_t raw); +void vkb_dec_VkPhysicalDevicePushDescriptorPropertiesKHR(vkb_dec *d, VkPhysicalDevicePushDescriptorPropertiesKHR *s); +void vkb_decfix_VkPhysicalDevicePushDescriptorPropertiesKHR(vkb_dec *d, VkPhysicalDevicePushDescriptorPropertiesKHR *s); +void vkb_enc_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(vkb_dec *d, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(vkb_dec *d, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceRobustness2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRobustness2FeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceRobustness2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRobustness2FeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceRobustness2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceRobustness2FeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceRobustness2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceRobustness2FeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceRobustness2PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceRobustness2PropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceRobustness2PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceRobustness2PropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceRobustness2PropertiesEXT(vkb_dec *d, VkPhysicalDeviceRobustness2PropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceRobustness2PropertiesEXT(vkb_dec *d, VkPhysicalDeviceRobustness2PropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceSampleLocationsPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceSampleLocationsPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkb_dec *d, VkPhysicalDeviceSampleLocationsPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkb_dec *d, VkPhysicalDeviceSampleLocationsPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkb_enc *e, const VkPhysicalDeviceSamplerFilterMinmaxProperties *s); +void vkb_encfix_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkb_enc *e, const VkPhysicalDeviceSamplerFilterMinmaxProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkb_dec *d, VkPhysicalDeviceSamplerFilterMinmaxProperties *s); +void vkb_decfix_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkb_dec *d, VkPhysicalDeviceSamplerFilterMinmaxProperties *s); +void vkb_enc_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkb_enc *e, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *s); +void vkb_encfix_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkb_enc *e, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkb_dec *d, VkPhysicalDeviceSamplerYcbcrConversionFeatures *s); +void vkb_decfix_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkb_dec *d, VkPhysicalDeviceSamplerYcbcrConversionFeatures *s); +void vkb_enc_VkPhysicalDeviceScalarBlockLayoutFeatures(vkb_enc *e, const VkPhysicalDeviceScalarBlockLayoutFeatures *s); +void vkb_encfix_VkPhysicalDeviceScalarBlockLayoutFeatures(vkb_enc *e, const VkPhysicalDeviceScalarBlockLayoutFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceScalarBlockLayoutFeatures(vkb_dec *d, VkPhysicalDeviceScalarBlockLayoutFeatures *s); +void vkb_decfix_VkPhysicalDeviceScalarBlockLayoutFeatures(vkb_dec *d, VkPhysicalDeviceScalarBlockLayoutFeatures *s); +void vkb_enc_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkb_enc *e, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *s); +void vkb_encfix_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkb_enc *e, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkb_dec *d, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *s); +void vkb_decfix_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkb_dec *d, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *s); +void vkb_enc_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceShaderAtomicInt64Features(vkb_enc *e, const VkPhysicalDeviceShaderAtomicInt64Features *s); +void vkb_encfix_VkPhysicalDeviceShaderAtomicInt64Features(vkb_enc *e, const VkPhysicalDeviceShaderAtomicInt64Features *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderAtomicInt64Features(vkb_dec *d, VkPhysicalDeviceShaderAtomicInt64Features *s); +void vkb_decfix_VkPhysicalDeviceShaderAtomicInt64Features(vkb_dec *d, VkPhysicalDeviceShaderAtomicInt64Features *s); +void vkb_enc_VkPhysicalDeviceShaderClockFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceShaderClockFeaturesKHR *s); +void vkb_encfix_VkPhysicalDeviceShaderClockFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceShaderClockFeaturesKHR *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderClockFeaturesKHR(vkb_dec *d, VkPhysicalDeviceShaderClockFeaturesKHR *s); +void vkb_decfix_VkPhysicalDeviceShaderClockFeaturesKHR(vkb_dec *d, VkPhysicalDeviceShaderClockFeaturesKHR *s); +void vkb_enc_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(vkb_enc *e, const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *s); +void vkb_encfix_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(vkb_enc *e, const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(vkb_dec *d, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *s); +void vkb_decfix_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(vkb_dec *d, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *s); +void vkb_enc_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(vkb_enc *e, const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *s); +void vkb_encfix_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(vkb_enc *e, const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(vkb_dec *d, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *s); +void vkb_decfix_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(vkb_dec *d, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *s); +void vkb_enc_VkPhysicalDeviceShaderCorePropertiesARM(vkb_enc *e, const VkPhysicalDeviceShaderCorePropertiesARM *s); +void vkb_encfix_VkPhysicalDeviceShaderCorePropertiesARM(vkb_enc *e, const VkPhysicalDeviceShaderCorePropertiesARM *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderCorePropertiesARM(vkb_dec *d, VkPhysicalDeviceShaderCorePropertiesARM *s); +void vkb_decfix_VkPhysicalDeviceShaderCorePropertiesARM(vkb_dec *d, VkPhysicalDeviceShaderCorePropertiesARM *s); +void vkb_enc_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(vkb_enc *e, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *s); +void vkb_encfix_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(vkb_enc *e, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(vkb_dec *d, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *s); +void vkb_decfix_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(vkb_dec *d, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *s); +void vkb_enc_VkPhysicalDeviceShaderDrawParametersFeatures(vkb_enc *e, const VkPhysicalDeviceShaderDrawParametersFeatures *s); +void vkb_encfix_VkPhysicalDeviceShaderDrawParametersFeatures(vkb_enc *e, const VkPhysicalDeviceShaderDrawParametersFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderDrawParametersFeatures(vkb_dec *d, VkPhysicalDeviceShaderDrawParametersFeatures *s); +void vkb_decfix_VkPhysicalDeviceShaderDrawParametersFeatures(vkb_dec *d, VkPhysicalDeviceShaderDrawParametersFeatures *s); +void vkb_enc_VkPhysicalDeviceShaderFloat16Int8Features(vkb_enc *e, const VkPhysicalDeviceShaderFloat16Int8Features *s); +void vkb_encfix_VkPhysicalDeviceShaderFloat16Int8Features(vkb_enc *e, const VkPhysicalDeviceShaderFloat16Int8Features *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderFloat16Int8Features(vkb_dec *d, VkPhysicalDeviceShaderFloat16Int8Features *s); +void vkb_decfix_VkPhysicalDeviceShaderFloat16Int8Features(vkb_dec *d, VkPhysicalDeviceShaderFloat16Int8Features *s); +void vkb_enc_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceShaderIntegerDotProductFeatures(vkb_enc *e, const VkPhysicalDeviceShaderIntegerDotProductFeatures *s); +void vkb_encfix_VkPhysicalDeviceShaderIntegerDotProductFeatures(vkb_enc *e, const VkPhysicalDeviceShaderIntegerDotProductFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderIntegerDotProductFeatures(vkb_dec *d, VkPhysicalDeviceShaderIntegerDotProductFeatures *s); +void vkb_decfix_VkPhysicalDeviceShaderIntegerDotProductFeatures(vkb_dec *d, VkPhysicalDeviceShaderIntegerDotProductFeatures *s); +void vkb_enc_VkPhysicalDeviceShaderIntegerDotProductProperties(vkb_enc *e, const VkPhysicalDeviceShaderIntegerDotProductProperties *s); +void vkb_encfix_VkPhysicalDeviceShaderIntegerDotProductProperties(vkb_enc *e, const VkPhysicalDeviceShaderIntegerDotProductProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderIntegerDotProductProperties(vkb_dec *d, VkPhysicalDeviceShaderIntegerDotProductProperties *s); +void vkb_decfix_VkPhysicalDeviceShaderIntegerDotProductProperties(vkb_dec *d, VkPhysicalDeviceShaderIntegerDotProductProperties *s); +void vkb_enc_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(vkb_dec *d, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(vkb_dec *d, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkb_enc *e, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *s); +void vkb_encfix_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkb_enc *e, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkb_dec *d, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *s); +void vkb_decfix_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkb_dec *d, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *s); +void vkb_enc_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *s); +void vkb_encfix_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(vkb_dec *d, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *s); +void vkb_decfix_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(vkb_dec *d, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *s); +void vkb_enc_VkPhysicalDeviceShaderTerminateInvocationFeatures(vkb_enc *e, const VkPhysicalDeviceShaderTerminateInvocationFeatures *s); +void vkb_encfix_VkPhysicalDeviceShaderTerminateInvocationFeatures(vkb_enc *e, const VkPhysicalDeviceShaderTerminateInvocationFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderTerminateInvocationFeatures(vkb_dec *d, VkPhysicalDeviceShaderTerminateInvocationFeatures *s); +void vkb_decfix_VkPhysicalDeviceShaderTerminateInvocationFeatures(vkb_dec *d, VkPhysicalDeviceShaderTerminateInvocationFeatures *s); +void vkb_enc_VkPhysicalDeviceShaderTileImageFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderTileImageFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceShaderTileImageFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderTileImageFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderTileImageFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderTileImageFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceShaderTileImageFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderTileImageFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceShaderTileImagePropertiesEXT(vkb_enc *e, const VkPhysicalDeviceShaderTileImagePropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceShaderTileImagePropertiesEXT(vkb_enc *e, const VkPhysicalDeviceShaderTileImagePropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceShaderTileImagePropertiesEXT(vkb_dec *d, VkPhysicalDeviceShaderTileImagePropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceShaderTileImagePropertiesEXT(vkb_dec *d, VkPhysicalDeviceShaderTileImagePropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceSparseImageFormatInfo2(vkb_enc *e, const VkPhysicalDeviceSparseImageFormatInfo2 *s); +void vkb_encfix_VkPhysicalDeviceSparseImageFormatInfo2(vkb_enc *e, const VkPhysicalDeviceSparseImageFormatInfo2 *s, size_t raw); +void vkb_dec_VkPhysicalDeviceSparseImageFormatInfo2(vkb_dec *d, VkPhysicalDeviceSparseImageFormatInfo2 *s); +void vkb_decfix_VkPhysicalDeviceSparseImageFormatInfo2(vkb_dec *d, VkPhysicalDeviceSparseImageFormatInfo2 *s); +void vkb_enc_VkPhysicalDeviceSubgroupProperties(vkb_enc *e, const VkPhysicalDeviceSubgroupProperties *s); +void vkb_encfix_VkPhysicalDeviceSubgroupProperties(vkb_enc *e, const VkPhysicalDeviceSubgroupProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceSubgroupProperties(vkb_dec *d, VkPhysicalDeviceSubgroupProperties *s); +void vkb_decfix_VkPhysicalDeviceSubgroupProperties(vkb_dec *d, VkPhysicalDeviceSubgroupProperties *s); +void vkb_enc_VkPhysicalDeviceSubgroupSizeControlFeatures(vkb_enc *e, const VkPhysicalDeviceSubgroupSizeControlFeatures *s); +void vkb_encfix_VkPhysicalDeviceSubgroupSizeControlFeatures(vkb_enc *e, const VkPhysicalDeviceSubgroupSizeControlFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceSubgroupSizeControlFeatures(vkb_dec *d, VkPhysicalDeviceSubgroupSizeControlFeatures *s); +void vkb_decfix_VkPhysicalDeviceSubgroupSizeControlFeatures(vkb_dec *d, VkPhysicalDeviceSubgroupSizeControlFeatures *s); +void vkb_enc_VkPhysicalDeviceSubgroupSizeControlProperties(vkb_enc *e, const VkPhysicalDeviceSubgroupSizeControlProperties *s); +void vkb_encfix_VkPhysicalDeviceSubgroupSizeControlProperties(vkb_enc *e, const VkPhysicalDeviceSubgroupSizeControlProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceSubgroupSizeControlProperties(vkb_dec *d, VkPhysicalDeviceSubgroupSizeControlProperties *s); +void vkb_decfix_VkPhysicalDeviceSubgroupSizeControlProperties(vkb_dec *d, VkPhysicalDeviceSubgroupSizeControlProperties *s); +void vkb_enc_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(vkb_dec *d, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(vkb_dec *d, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceSynchronization2Features(vkb_enc *e, const VkPhysicalDeviceSynchronization2Features *s); +void vkb_encfix_VkPhysicalDeviceSynchronization2Features(vkb_enc *e, const VkPhysicalDeviceSynchronization2Features *s, size_t raw); +void vkb_dec_VkPhysicalDeviceSynchronization2Features(vkb_dec *d, VkPhysicalDeviceSynchronization2Features *s); +void vkb_decfix_VkPhysicalDeviceSynchronization2Features(vkb_dec *d, VkPhysicalDeviceSynchronization2Features *s); +void vkb_enc_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkb_dec *d, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkb_dec *d, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceTexelBufferAlignmentProperties(vkb_enc *e, const VkPhysicalDeviceTexelBufferAlignmentProperties *s); +void vkb_encfix_VkPhysicalDeviceTexelBufferAlignmentProperties(vkb_enc *e, const VkPhysicalDeviceTexelBufferAlignmentProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceTexelBufferAlignmentProperties(vkb_dec *d, VkPhysicalDeviceTexelBufferAlignmentProperties *s); +void vkb_decfix_VkPhysicalDeviceTexelBufferAlignmentProperties(vkb_dec *d, VkPhysicalDeviceTexelBufferAlignmentProperties *s); +void vkb_enc_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(vkb_enc *e, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *s); +void vkb_encfix_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(vkb_enc *e, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(vkb_dec *d, VkPhysicalDeviceTextureCompressionASTCHDRFeatures *s); +void vkb_decfix_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(vkb_dec *d, VkPhysicalDeviceTextureCompressionASTCHDRFeatures *s); +void vkb_enc_VkPhysicalDeviceTimelineSemaphoreFeatures(vkb_enc *e, const VkPhysicalDeviceTimelineSemaphoreFeatures *s); +void vkb_encfix_VkPhysicalDeviceTimelineSemaphoreFeatures(vkb_enc *e, const VkPhysicalDeviceTimelineSemaphoreFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceTimelineSemaphoreFeatures(vkb_dec *d, VkPhysicalDeviceTimelineSemaphoreFeatures *s); +void vkb_decfix_VkPhysicalDeviceTimelineSemaphoreFeatures(vkb_dec *d, VkPhysicalDeviceTimelineSemaphoreFeatures *s); +void vkb_enc_VkPhysicalDeviceTimelineSemaphoreProperties(vkb_enc *e, const VkPhysicalDeviceTimelineSemaphoreProperties *s); +void vkb_encfix_VkPhysicalDeviceTimelineSemaphoreProperties(vkb_enc *e, const VkPhysicalDeviceTimelineSemaphoreProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceTimelineSemaphoreProperties(vkb_dec *d, VkPhysicalDeviceTimelineSemaphoreProperties *s); +void vkb_decfix_VkPhysicalDeviceTimelineSemaphoreProperties(vkb_dec *d, VkPhysicalDeviceTimelineSemaphoreProperties *s); +void vkb_enc_VkPhysicalDeviceToolProperties(vkb_enc *e, const VkPhysicalDeviceToolProperties *s); +void vkb_encfix_VkPhysicalDeviceToolProperties(vkb_enc *e, const VkPhysicalDeviceToolProperties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceToolProperties(vkb_dec *d, VkPhysicalDeviceToolProperties *s); +void vkb_decfix_VkPhysicalDeviceToolProperties(vkb_dec *d, VkPhysicalDeviceToolProperties *s); +void vkb_enc_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkb_dec *d, VkPhysicalDeviceTransformFeedbackFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkb_dec *d, VkPhysicalDeviceTransformFeedbackFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkb_dec *d, VkPhysicalDeviceTransformFeedbackPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkb_dec *d, VkPhysicalDeviceTransformFeedbackPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkb_enc *e, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *s); +void vkb_encfix_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkb_enc *e, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkb_dec *d, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *s); +void vkb_decfix_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkb_dec *d, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *s); +void vkb_enc_VkPhysicalDeviceVariablePointersFeatures(vkb_enc *e, const VkPhysicalDeviceVariablePointersFeatures *s); +void vkb_encfix_VkPhysicalDeviceVariablePointersFeatures(vkb_enc *e, const VkPhysicalDeviceVariablePointersFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceVariablePointersFeatures(vkb_dec *d, VkPhysicalDeviceVariablePointersFeatures *s); +void vkb_decfix_VkPhysicalDeviceVariablePointersFeatures(vkb_dec *d, VkPhysicalDeviceVariablePointersFeatures *s); +void vkb_enc_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkb_dec *d, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkb_dec *d, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *s); +void vkb_encfix_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkb_dec *d, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *s); +void vkb_decfix_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkb_dec *d, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *s); +void vkb_enc_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(vkb_dec *d, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(vkb_dec *d, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceVulkan11Features(vkb_enc *e, const VkPhysicalDeviceVulkan11Features *s); +void vkb_encfix_VkPhysicalDeviceVulkan11Features(vkb_enc *e, const VkPhysicalDeviceVulkan11Features *s, size_t raw); +void vkb_dec_VkPhysicalDeviceVulkan11Features(vkb_dec *d, VkPhysicalDeviceVulkan11Features *s); +void vkb_decfix_VkPhysicalDeviceVulkan11Features(vkb_dec *d, VkPhysicalDeviceVulkan11Features *s); +void vkb_enc_VkPhysicalDeviceVulkan11Properties(vkb_enc *e, const VkPhysicalDeviceVulkan11Properties *s); +void vkb_encfix_VkPhysicalDeviceVulkan11Properties(vkb_enc *e, const VkPhysicalDeviceVulkan11Properties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceVulkan11Properties(vkb_dec *d, VkPhysicalDeviceVulkan11Properties *s); +void vkb_decfix_VkPhysicalDeviceVulkan11Properties(vkb_dec *d, VkPhysicalDeviceVulkan11Properties *s); +void vkb_enc_VkPhysicalDeviceVulkan12Features(vkb_enc *e, const VkPhysicalDeviceVulkan12Features *s); +void vkb_encfix_VkPhysicalDeviceVulkan12Features(vkb_enc *e, const VkPhysicalDeviceVulkan12Features *s, size_t raw); +void vkb_dec_VkPhysicalDeviceVulkan12Features(vkb_dec *d, VkPhysicalDeviceVulkan12Features *s); +void vkb_decfix_VkPhysicalDeviceVulkan12Features(vkb_dec *d, VkPhysicalDeviceVulkan12Features *s); +void vkb_enc_VkPhysicalDeviceVulkan12Properties(vkb_enc *e, const VkPhysicalDeviceVulkan12Properties *s); +void vkb_encfix_VkPhysicalDeviceVulkan12Properties(vkb_enc *e, const VkPhysicalDeviceVulkan12Properties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceVulkan12Properties(vkb_dec *d, VkPhysicalDeviceVulkan12Properties *s); +void vkb_decfix_VkPhysicalDeviceVulkan12Properties(vkb_dec *d, VkPhysicalDeviceVulkan12Properties *s); +void vkb_enc_VkPhysicalDeviceVulkan13Features(vkb_enc *e, const VkPhysicalDeviceVulkan13Features *s); +void vkb_encfix_VkPhysicalDeviceVulkan13Features(vkb_enc *e, const VkPhysicalDeviceVulkan13Features *s, size_t raw); +void vkb_dec_VkPhysicalDeviceVulkan13Features(vkb_dec *d, VkPhysicalDeviceVulkan13Features *s); +void vkb_decfix_VkPhysicalDeviceVulkan13Features(vkb_dec *d, VkPhysicalDeviceVulkan13Features *s); +void vkb_enc_VkPhysicalDeviceVulkan13Properties(vkb_enc *e, const VkPhysicalDeviceVulkan13Properties *s); +void vkb_encfix_VkPhysicalDeviceVulkan13Properties(vkb_enc *e, const VkPhysicalDeviceVulkan13Properties *s, size_t raw); +void vkb_dec_VkPhysicalDeviceVulkan13Properties(vkb_dec *d, VkPhysicalDeviceVulkan13Properties *s); +void vkb_decfix_VkPhysicalDeviceVulkan13Properties(vkb_dec *d, VkPhysicalDeviceVulkan13Properties *s); +void vkb_enc_VkPhysicalDeviceVulkanMemoryModelFeatures(vkb_enc *e, const VkPhysicalDeviceVulkanMemoryModelFeatures *s); +void vkb_encfix_VkPhysicalDeviceVulkanMemoryModelFeatures(vkb_enc *e, const VkPhysicalDeviceVulkanMemoryModelFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceVulkanMemoryModelFeatures(vkb_dec *d, VkPhysicalDeviceVulkanMemoryModelFeatures *s); +void vkb_decfix_VkPhysicalDeviceVulkanMemoryModelFeatures(vkb_dec *d, VkPhysicalDeviceVulkanMemoryModelFeatures *s); +void vkb_enc_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *s); +void vkb_encfix_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *s, size_t raw); +void vkb_dec_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(vkb_dec *d, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *s); +void vkb_decfix_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(vkb_dec *d, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *s); +void vkb_enc_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *s); +void vkb_encfix_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *s, size_t raw); +void vkb_dec_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkb_dec *d, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *s); +void vkb_decfix_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkb_dec *d, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *s); +void vkb_enc_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(vkb_enc *e, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *s); +void vkb_encfix_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(vkb_enc *e, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *s, size_t raw); +void vkb_dec_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(vkb_dec *d, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *s); +void vkb_decfix_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(vkb_dec *d, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *s); +void vkb_enc_VkPipelineCacheCreateInfo(vkb_enc *e, const VkPipelineCacheCreateInfo *s); +void vkb_encfix_VkPipelineCacheCreateInfo(vkb_enc *e, const VkPipelineCacheCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineCacheCreateInfo(vkb_dec *d, VkPipelineCacheCreateInfo *s); +void vkb_decfix_VkPipelineCacheCreateInfo(vkb_dec *d, VkPipelineCacheCreateInfo *s); +void vkb_enc_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkb_enc *e, const VkPipelineColorBlendAdvancedStateCreateInfoEXT *s); +void vkb_encfix_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkb_enc *e, const VkPipelineColorBlendAdvancedStateCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkb_dec *d, VkPipelineColorBlendAdvancedStateCreateInfoEXT *s); +void vkb_decfix_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkb_dec *d, VkPipelineColorBlendAdvancedStateCreateInfoEXT *s); +void vkb_enc_VkPipelineColorBlendStateCreateInfo(vkb_enc *e, const VkPipelineColorBlendStateCreateInfo *s); +void vkb_encfix_VkPipelineColorBlendStateCreateInfo(vkb_enc *e, const VkPipelineColorBlendStateCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineColorBlendStateCreateInfo(vkb_dec *d, VkPipelineColorBlendStateCreateInfo *s); +void vkb_decfix_VkPipelineColorBlendStateCreateInfo(vkb_dec *d, VkPipelineColorBlendStateCreateInfo *s); +void vkb_enc_VkPipelineColorWriteCreateInfoEXT(vkb_enc *e, const VkPipelineColorWriteCreateInfoEXT *s); +void vkb_encfix_VkPipelineColorWriteCreateInfoEXT(vkb_enc *e, const VkPipelineColorWriteCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineColorWriteCreateInfoEXT(vkb_dec *d, VkPipelineColorWriteCreateInfoEXT *s); +void vkb_decfix_VkPipelineColorWriteCreateInfoEXT(vkb_dec *d, VkPipelineColorWriteCreateInfoEXT *s); +void vkb_enc_VkPipelineCreationFeedbackCreateInfo(vkb_enc *e, const VkPipelineCreationFeedbackCreateInfo *s); +void vkb_encfix_VkPipelineCreationFeedbackCreateInfo(vkb_enc *e, const VkPipelineCreationFeedbackCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineCreationFeedbackCreateInfo(vkb_dec *d, VkPipelineCreationFeedbackCreateInfo *s); +void vkb_decfix_VkPipelineCreationFeedbackCreateInfo(vkb_dec *d, VkPipelineCreationFeedbackCreateInfo *s); +void vkb_enc_VkPipelineDepthStencilStateCreateInfo(vkb_enc *e, const VkPipelineDepthStencilStateCreateInfo *s); +void vkb_encfix_VkPipelineDepthStencilStateCreateInfo(vkb_enc *e, const VkPipelineDepthStencilStateCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineDepthStencilStateCreateInfo(vkb_dec *d, VkPipelineDepthStencilStateCreateInfo *s); +void vkb_decfix_VkPipelineDepthStencilStateCreateInfo(vkb_dec *d, VkPipelineDepthStencilStateCreateInfo *s); +void vkb_enc_VkPipelineDiscardRectangleStateCreateInfoEXT(vkb_enc *e, const VkPipelineDiscardRectangleStateCreateInfoEXT *s); +void vkb_encfix_VkPipelineDiscardRectangleStateCreateInfoEXT(vkb_enc *e, const VkPipelineDiscardRectangleStateCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineDiscardRectangleStateCreateInfoEXT(vkb_dec *d, VkPipelineDiscardRectangleStateCreateInfoEXT *s); +void vkb_decfix_VkPipelineDiscardRectangleStateCreateInfoEXT(vkb_dec *d, VkPipelineDiscardRectangleStateCreateInfoEXT *s); +void vkb_enc_VkPipelineDynamicStateCreateInfo(vkb_enc *e, const VkPipelineDynamicStateCreateInfo *s); +void vkb_encfix_VkPipelineDynamicStateCreateInfo(vkb_enc *e, const VkPipelineDynamicStateCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineDynamicStateCreateInfo(vkb_dec *d, VkPipelineDynamicStateCreateInfo *s); +void vkb_decfix_VkPipelineDynamicStateCreateInfo(vkb_dec *d, VkPipelineDynamicStateCreateInfo *s); +void vkb_enc_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkb_enc *e, const VkPipelineFragmentShadingRateStateCreateInfoKHR *s); +void vkb_encfix_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkb_enc *e, const VkPipelineFragmentShadingRateStateCreateInfoKHR *s, size_t raw); +void vkb_dec_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkb_dec *d, VkPipelineFragmentShadingRateStateCreateInfoKHR *s); +void vkb_decfix_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkb_dec *d, VkPipelineFragmentShadingRateStateCreateInfoKHR *s); +void vkb_enc_VkPipelineInputAssemblyStateCreateInfo(vkb_enc *e, const VkPipelineInputAssemblyStateCreateInfo *s); +void vkb_encfix_VkPipelineInputAssemblyStateCreateInfo(vkb_enc *e, const VkPipelineInputAssemblyStateCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineInputAssemblyStateCreateInfo(vkb_dec *d, VkPipelineInputAssemblyStateCreateInfo *s); +void vkb_decfix_VkPipelineInputAssemblyStateCreateInfo(vkb_dec *d, VkPipelineInputAssemblyStateCreateInfo *s); +void vkb_enc_VkPipelineLayoutCreateInfo(vkb_enc *e, const VkPipelineLayoutCreateInfo *s); +void vkb_encfix_VkPipelineLayoutCreateInfo(vkb_enc *e, const VkPipelineLayoutCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineLayoutCreateInfo(vkb_dec *d, VkPipelineLayoutCreateInfo *s); +void vkb_decfix_VkPipelineLayoutCreateInfo(vkb_dec *d, VkPipelineLayoutCreateInfo *s); +void vkb_enc_VkPipelineLibraryCreateInfoKHR(vkb_enc *e, const VkPipelineLibraryCreateInfoKHR *s); +void vkb_encfix_VkPipelineLibraryCreateInfoKHR(vkb_enc *e, const VkPipelineLibraryCreateInfoKHR *s, size_t raw); +void vkb_dec_VkPipelineLibraryCreateInfoKHR(vkb_dec *d, VkPipelineLibraryCreateInfoKHR *s); +void vkb_decfix_VkPipelineLibraryCreateInfoKHR(vkb_dec *d, VkPipelineLibraryCreateInfoKHR *s); +void vkb_enc_VkPipelineMultisampleStateCreateInfo(vkb_enc *e, const VkPipelineMultisampleStateCreateInfo *s); +void vkb_encfix_VkPipelineMultisampleStateCreateInfo(vkb_enc *e, const VkPipelineMultisampleStateCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineMultisampleStateCreateInfo(vkb_dec *d, VkPipelineMultisampleStateCreateInfo *s); +void vkb_decfix_VkPipelineMultisampleStateCreateInfo(vkb_dec *d, VkPipelineMultisampleStateCreateInfo *s); +void vkb_enc_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationConservativeStateCreateInfoEXT *s); +void vkb_encfix_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationConservativeStateCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationConservativeStateCreateInfoEXT *s); +void vkb_decfix_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationConservativeStateCreateInfoEXT *s); +void vkb_enc_VkPipelineRasterizationDepthClipStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationDepthClipStateCreateInfoEXT *s); +void vkb_encfix_VkPipelineRasterizationDepthClipStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationDepthClipStateCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineRasterizationDepthClipStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationDepthClipStateCreateInfoEXT *s); +void vkb_decfix_VkPipelineRasterizationDepthClipStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationDepthClipStateCreateInfoEXT *s); +void vkb_enc_VkPipelineRasterizationLineStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationLineStateCreateInfoEXT *s); +void vkb_encfix_VkPipelineRasterizationLineStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationLineStateCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineRasterizationLineStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationLineStateCreateInfoEXT *s); +void vkb_decfix_VkPipelineRasterizationLineStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationLineStateCreateInfoEXT *s); +void vkb_enc_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *s); +void vkb_encfix_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *s); +void vkb_decfix_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *s); +void vkb_enc_VkPipelineRasterizationStateCreateInfo(vkb_enc *e, const VkPipelineRasterizationStateCreateInfo *s); +void vkb_encfix_VkPipelineRasterizationStateCreateInfo(vkb_enc *e, const VkPipelineRasterizationStateCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineRasterizationStateCreateInfo(vkb_dec *d, VkPipelineRasterizationStateCreateInfo *s); +void vkb_decfix_VkPipelineRasterizationStateCreateInfo(vkb_dec *d, VkPipelineRasterizationStateCreateInfo *s); +void vkb_enc_VkPipelineRasterizationStateStreamCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationStateStreamCreateInfoEXT *s); +void vkb_encfix_VkPipelineRasterizationStateStreamCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationStateStreamCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineRasterizationStateStreamCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationStateStreamCreateInfoEXT *s); +void vkb_decfix_VkPipelineRasterizationStateStreamCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationStateStreamCreateInfoEXT *s); +void vkb_enc_VkPipelineRenderingCreateInfo(vkb_enc *e, const VkPipelineRenderingCreateInfo *s); +void vkb_encfix_VkPipelineRenderingCreateInfo(vkb_enc *e, const VkPipelineRenderingCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineRenderingCreateInfo(vkb_dec *d, VkPipelineRenderingCreateInfo *s); +void vkb_decfix_VkPipelineRenderingCreateInfo(vkb_dec *d, VkPipelineRenderingCreateInfo *s); +void vkb_enc_VkPipelineRobustnessCreateInfoEXT(vkb_enc *e, const VkPipelineRobustnessCreateInfoEXT *s); +void vkb_encfix_VkPipelineRobustnessCreateInfoEXT(vkb_enc *e, const VkPipelineRobustnessCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineRobustnessCreateInfoEXT(vkb_dec *d, VkPipelineRobustnessCreateInfoEXT *s); +void vkb_decfix_VkPipelineRobustnessCreateInfoEXT(vkb_dec *d, VkPipelineRobustnessCreateInfoEXT *s); +void vkb_enc_VkPipelineSampleLocationsStateCreateInfoEXT(vkb_enc *e, const VkPipelineSampleLocationsStateCreateInfoEXT *s); +void vkb_encfix_VkPipelineSampleLocationsStateCreateInfoEXT(vkb_enc *e, const VkPipelineSampleLocationsStateCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineSampleLocationsStateCreateInfoEXT(vkb_dec *d, VkPipelineSampleLocationsStateCreateInfoEXT *s); +void vkb_decfix_VkPipelineSampleLocationsStateCreateInfoEXT(vkb_dec *d, VkPipelineSampleLocationsStateCreateInfoEXT *s); +void vkb_enc_VkPipelineShaderStageCreateInfo(vkb_enc *e, const VkPipelineShaderStageCreateInfo *s); +void vkb_encfix_VkPipelineShaderStageCreateInfo(vkb_enc *e, const VkPipelineShaderStageCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineShaderStageCreateInfo(vkb_dec *d, VkPipelineShaderStageCreateInfo *s); +void vkb_decfix_VkPipelineShaderStageCreateInfo(vkb_dec *d, VkPipelineShaderStageCreateInfo *s); +void vkb_enc_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(vkb_enc *e, const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *s); +void vkb_encfix_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(vkb_enc *e, const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(vkb_dec *d, VkPipelineShaderStageModuleIdentifierCreateInfoEXT *s); +void vkb_decfix_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(vkb_dec *d, VkPipelineShaderStageModuleIdentifierCreateInfoEXT *s); +void vkb_enc_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(vkb_enc *e, const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *s); +void vkb_encfix_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(vkb_enc *e, const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(vkb_dec *d, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *s); +void vkb_decfix_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(vkb_dec *d, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *s); +void vkb_enc_VkPipelineTessellationDomainOriginStateCreateInfo(vkb_enc *e, const VkPipelineTessellationDomainOriginStateCreateInfo *s); +void vkb_encfix_VkPipelineTessellationDomainOriginStateCreateInfo(vkb_enc *e, const VkPipelineTessellationDomainOriginStateCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineTessellationDomainOriginStateCreateInfo(vkb_dec *d, VkPipelineTessellationDomainOriginStateCreateInfo *s); +void vkb_decfix_VkPipelineTessellationDomainOriginStateCreateInfo(vkb_dec *d, VkPipelineTessellationDomainOriginStateCreateInfo *s); +void vkb_enc_VkPipelineTessellationStateCreateInfo(vkb_enc *e, const VkPipelineTessellationStateCreateInfo *s); +void vkb_encfix_VkPipelineTessellationStateCreateInfo(vkb_enc *e, const VkPipelineTessellationStateCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineTessellationStateCreateInfo(vkb_dec *d, VkPipelineTessellationStateCreateInfo *s); +void vkb_decfix_VkPipelineTessellationStateCreateInfo(vkb_dec *d, VkPipelineTessellationStateCreateInfo *s); +void vkb_enc_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkb_enc *e, const VkPipelineVertexInputDivisorStateCreateInfoEXT *s); +void vkb_encfix_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkb_enc *e, const VkPipelineVertexInputDivisorStateCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkb_dec *d, VkPipelineVertexInputDivisorStateCreateInfoEXT *s); +void vkb_decfix_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkb_dec *d, VkPipelineVertexInputDivisorStateCreateInfoEXT *s); +void vkb_enc_VkPipelineVertexInputStateCreateInfo(vkb_enc *e, const VkPipelineVertexInputStateCreateInfo *s); +void vkb_encfix_VkPipelineVertexInputStateCreateInfo(vkb_enc *e, const VkPipelineVertexInputStateCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineVertexInputStateCreateInfo(vkb_dec *d, VkPipelineVertexInputStateCreateInfo *s); +void vkb_decfix_VkPipelineVertexInputStateCreateInfo(vkb_dec *d, VkPipelineVertexInputStateCreateInfo *s); +void vkb_enc_VkPipelineViewportDepthClipControlCreateInfoEXT(vkb_enc *e, const VkPipelineViewportDepthClipControlCreateInfoEXT *s); +void vkb_encfix_VkPipelineViewportDepthClipControlCreateInfoEXT(vkb_enc *e, const VkPipelineViewportDepthClipControlCreateInfoEXT *s, size_t raw); +void vkb_dec_VkPipelineViewportDepthClipControlCreateInfoEXT(vkb_dec *d, VkPipelineViewportDepthClipControlCreateInfoEXT *s); +void vkb_decfix_VkPipelineViewportDepthClipControlCreateInfoEXT(vkb_dec *d, VkPipelineViewportDepthClipControlCreateInfoEXT *s); +void vkb_enc_VkPipelineViewportStateCreateInfo(vkb_enc *e, const VkPipelineViewportStateCreateInfo *s); +void vkb_encfix_VkPipelineViewportStateCreateInfo(vkb_enc *e, const VkPipelineViewportStateCreateInfo *s, size_t raw); +void vkb_dec_VkPipelineViewportStateCreateInfo(vkb_dec *d, VkPipelineViewportStateCreateInfo *s); +void vkb_decfix_VkPipelineViewportStateCreateInfo(vkb_dec *d, VkPipelineViewportStateCreateInfo *s); +void vkb_enc_VkProtectedSubmitInfo(vkb_enc *e, const VkProtectedSubmitInfo *s); +void vkb_encfix_VkProtectedSubmitInfo(vkb_enc *e, const VkProtectedSubmitInfo *s, size_t raw); +void vkb_dec_VkProtectedSubmitInfo(vkb_dec *d, VkProtectedSubmitInfo *s); +void vkb_decfix_VkProtectedSubmitInfo(vkb_dec *d, VkProtectedSubmitInfo *s); +void vkb_enc_VkQueryPoolCreateInfo(vkb_enc *e, const VkQueryPoolCreateInfo *s); +void vkb_encfix_VkQueryPoolCreateInfo(vkb_enc *e, const VkQueryPoolCreateInfo *s, size_t raw); +void vkb_dec_VkQueryPoolCreateInfo(vkb_dec *d, VkQueryPoolCreateInfo *s); +void vkb_decfix_VkQueryPoolCreateInfo(vkb_dec *d, VkQueryPoolCreateInfo *s); +void vkb_enc_VkQueueFamilyGlobalPriorityPropertiesKHR(vkb_enc *e, const VkQueueFamilyGlobalPriorityPropertiesKHR *s); +void vkb_encfix_VkQueueFamilyGlobalPriorityPropertiesKHR(vkb_enc *e, const VkQueueFamilyGlobalPriorityPropertiesKHR *s, size_t raw); +void vkb_dec_VkQueueFamilyGlobalPriorityPropertiesKHR(vkb_dec *d, VkQueueFamilyGlobalPriorityPropertiesKHR *s); +void vkb_decfix_VkQueueFamilyGlobalPriorityPropertiesKHR(vkb_dec *d, VkQueueFamilyGlobalPriorityPropertiesKHR *s); +void vkb_enc_VkQueueFamilyProperties2(vkb_enc *e, const VkQueueFamilyProperties2 *s); +void vkb_encfix_VkQueueFamilyProperties2(vkb_enc *e, const VkQueueFamilyProperties2 *s, size_t raw); +void vkb_dec_VkQueueFamilyProperties2(vkb_dec *d, VkQueueFamilyProperties2 *s); +void vkb_decfix_VkQueueFamilyProperties2(vkb_dec *d, VkQueueFamilyProperties2 *s); +void vkb_enc_VkRenderPassAttachmentBeginInfo(vkb_enc *e, const VkRenderPassAttachmentBeginInfo *s); +void vkb_encfix_VkRenderPassAttachmentBeginInfo(vkb_enc *e, const VkRenderPassAttachmentBeginInfo *s, size_t raw); +void vkb_dec_VkRenderPassAttachmentBeginInfo(vkb_dec *d, VkRenderPassAttachmentBeginInfo *s); +void vkb_decfix_VkRenderPassAttachmentBeginInfo(vkb_dec *d, VkRenderPassAttachmentBeginInfo *s); +void vkb_enc_VkRenderPassBeginInfo(vkb_enc *e, const VkRenderPassBeginInfo *s); +void vkb_encfix_VkRenderPassBeginInfo(vkb_enc *e, const VkRenderPassBeginInfo *s, size_t raw); +void vkb_dec_VkRenderPassBeginInfo(vkb_dec *d, VkRenderPassBeginInfo *s); +void vkb_decfix_VkRenderPassBeginInfo(vkb_dec *d, VkRenderPassBeginInfo *s); +void vkb_enc_VkRenderPassCreateInfo(vkb_enc *e, const VkRenderPassCreateInfo *s); +void vkb_encfix_VkRenderPassCreateInfo(vkb_enc *e, const VkRenderPassCreateInfo *s, size_t raw); +void vkb_dec_VkRenderPassCreateInfo(vkb_dec *d, VkRenderPassCreateInfo *s); +void vkb_decfix_VkRenderPassCreateInfo(vkb_dec *d, VkRenderPassCreateInfo *s); +void vkb_enc_VkRenderPassCreateInfo2(vkb_enc *e, const VkRenderPassCreateInfo2 *s); +void vkb_encfix_VkRenderPassCreateInfo2(vkb_enc *e, const VkRenderPassCreateInfo2 *s, size_t raw); +void vkb_dec_VkRenderPassCreateInfo2(vkb_dec *d, VkRenderPassCreateInfo2 *s); +void vkb_decfix_VkRenderPassCreateInfo2(vkb_dec *d, VkRenderPassCreateInfo2 *s); +void vkb_enc_VkRenderPassCreationControlEXT(vkb_enc *e, const VkRenderPassCreationControlEXT *s); +void vkb_encfix_VkRenderPassCreationControlEXT(vkb_enc *e, const VkRenderPassCreationControlEXT *s, size_t raw); +void vkb_dec_VkRenderPassCreationControlEXT(vkb_dec *d, VkRenderPassCreationControlEXT *s); +void vkb_decfix_VkRenderPassCreationControlEXT(vkb_dec *d, VkRenderPassCreationControlEXT *s); +void vkb_enc_VkRenderPassCreationFeedbackCreateInfoEXT(vkb_enc *e, const VkRenderPassCreationFeedbackCreateInfoEXT *s); +void vkb_encfix_VkRenderPassCreationFeedbackCreateInfoEXT(vkb_enc *e, const VkRenderPassCreationFeedbackCreateInfoEXT *s, size_t raw); +void vkb_dec_VkRenderPassCreationFeedbackCreateInfoEXT(vkb_dec *d, VkRenderPassCreationFeedbackCreateInfoEXT *s); +void vkb_decfix_VkRenderPassCreationFeedbackCreateInfoEXT(vkb_dec *d, VkRenderPassCreationFeedbackCreateInfoEXT *s); +void vkb_enc_VkRenderPassFragmentDensityMapCreateInfoEXT(vkb_enc *e, const VkRenderPassFragmentDensityMapCreateInfoEXT *s); +void vkb_encfix_VkRenderPassFragmentDensityMapCreateInfoEXT(vkb_enc *e, const VkRenderPassFragmentDensityMapCreateInfoEXT *s, size_t raw); +void vkb_dec_VkRenderPassFragmentDensityMapCreateInfoEXT(vkb_dec *d, VkRenderPassFragmentDensityMapCreateInfoEXT *s); +void vkb_decfix_VkRenderPassFragmentDensityMapCreateInfoEXT(vkb_dec *d, VkRenderPassFragmentDensityMapCreateInfoEXT *s); +void vkb_enc_VkRenderPassInputAttachmentAspectCreateInfo(vkb_enc *e, const VkRenderPassInputAttachmentAspectCreateInfo *s); +void vkb_encfix_VkRenderPassInputAttachmentAspectCreateInfo(vkb_enc *e, const VkRenderPassInputAttachmentAspectCreateInfo *s, size_t raw); +void vkb_dec_VkRenderPassInputAttachmentAspectCreateInfo(vkb_dec *d, VkRenderPassInputAttachmentAspectCreateInfo *s); +void vkb_decfix_VkRenderPassInputAttachmentAspectCreateInfo(vkb_dec *d, VkRenderPassInputAttachmentAspectCreateInfo *s); +void vkb_enc_VkRenderPassMultiviewCreateInfo(vkb_enc *e, const VkRenderPassMultiviewCreateInfo *s); +void vkb_encfix_VkRenderPassMultiviewCreateInfo(vkb_enc *e, const VkRenderPassMultiviewCreateInfo *s, size_t raw); +void vkb_dec_VkRenderPassMultiviewCreateInfo(vkb_dec *d, VkRenderPassMultiviewCreateInfo *s); +void vkb_decfix_VkRenderPassMultiviewCreateInfo(vkb_dec *d, VkRenderPassMultiviewCreateInfo *s); +void vkb_enc_VkRenderPassSampleLocationsBeginInfoEXT(vkb_enc *e, const VkRenderPassSampleLocationsBeginInfoEXT *s); +void vkb_encfix_VkRenderPassSampleLocationsBeginInfoEXT(vkb_enc *e, const VkRenderPassSampleLocationsBeginInfoEXT *s, size_t raw); +void vkb_dec_VkRenderPassSampleLocationsBeginInfoEXT(vkb_dec *d, VkRenderPassSampleLocationsBeginInfoEXT *s); +void vkb_decfix_VkRenderPassSampleLocationsBeginInfoEXT(vkb_dec *d, VkRenderPassSampleLocationsBeginInfoEXT *s); +void vkb_enc_VkRenderPassSubpassFeedbackCreateInfoEXT(vkb_enc *e, const VkRenderPassSubpassFeedbackCreateInfoEXT *s); +void vkb_encfix_VkRenderPassSubpassFeedbackCreateInfoEXT(vkb_enc *e, const VkRenderPassSubpassFeedbackCreateInfoEXT *s, size_t raw); +void vkb_dec_VkRenderPassSubpassFeedbackCreateInfoEXT(vkb_dec *d, VkRenderPassSubpassFeedbackCreateInfoEXT *s); +void vkb_decfix_VkRenderPassSubpassFeedbackCreateInfoEXT(vkb_dec *d, VkRenderPassSubpassFeedbackCreateInfoEXT *s); +void vkb_enc_VkRenderingAttachmentInfo(vkb_enc *e, const VkRenderingAttachmentInfo *s); +void vkb_encfix_VkRenderingAttachmentInfo(vkb_enc *e, const VkRenderingAttachmentInfo *s, size_t raw); +void vkb_dec_VkRenderingAttachmentInfo(vkb_dec *d, VkRenderingAttachmentInfo *s); +void vkb_decfix_VkRenderingAttachmentInfo(vkb_dec *d, VkRenderingAttachmentInfo *s); +void vkb_enc_VkRenderingFragmentDensityMapAttachmentInfoEXT(vkb_enc *e, const VkRenderingFragmentDensityMapAttachmentInfoEXT *s); +void vkb_encfix_VkRenderingFragmentDensityMapAttachmentInfoEXT(vkb_enc *e, const VkRenderingFragmentDensityMapAttachmentInfoEXT *s, size_t raw); +void vkb_dec_VkRenderingFragmentDensityMapAttachmentInfoEXT(vkb_dec *d, VkRenderingFragmentDensityMapAttachmentInfoEXT *s); +void vkb_decfix_VkRenderingFragmentDensityMapAttachmentInfoEXT(vkb_dec *d, VkRenderingFragmentDensityMapAttachmentInfoEXT *s); +void vkb_enc_VkRenderingFragmentShadingRateAttachmentInfoKHR(vkb_enc *e, const VkRenderingFragmentShadingRateAttachmentInfoKHR *s); +void vkb_encfix_VkRenderingFragmentShadingRateAttachmentInfoKHR(vkb_enc *e, const VkRenderingFragmentShadingRateAttachmentInfoKHR *s, size_t raw); +void vkb_dec_VkRenderingFragmentShadingRateAttachmentInfoKHR(vkb_dec *d, VkRenderingFragmentShadingRateAttachmentInfoKHR *s); +void vkb_decfix_VkRenderingFragmentShadingRateAttachmentInfoKHR(vkb_dec *d, VkRenderingFragmentShadingRateAttachmentInfoKHR *s); +void vkb_enc_VkRenderingInfo(vkb_enc *e, const VkRenderingInfo *s); +void vkb_encfix_VkRenderingInfo(vkb_enc *e, const VkRenderingInfo *s, size_t raw); +void vkb_dec_VkRenderingInfo(vkb_dec *d, VkRenderingInfo *s); +void vkb_decfix_VkRenderingInfo(vkb_dec *d, VkRenderingInfo *s); +void vkb_enc_VkResolveImageInfo2(vkb_enc *e, const VkResolveImageInfo2 *s); +void vkb_encfix_VkResolveImageInfo2(vkb_enc *e, const VkResolveImageInfo2 *s, size_t raw); +void vkb_dec_VkResolveImageInfo2(vkb_dec *d, VkResolveImageInfo2 *s); +void vkb_decfix_VkResolveImageInfo2(vkb_dec *d, VkResolveImageInfo2 *s); +void vkb_enc_VkSampleLocationsInfoEXT(vkb_enc *e, const VkSampleLocationsInfoEXT *s); +void vkb_encfix_VkSampleLocationsInfoEXT(vkb_enc *e, const VkSampleLocationsInfoEXT *s, size_t raw); +void vkb_dec_VkSampleLocationsInfoEXT(vkb_dec *d, VkSampleLocationsInfoEXT *s); +void vkb_decfix_VkSampleLocationsInfoEXT(vkb_dec *d, VkSampleLocationsInfoEXT *s); +void vkb_enc_VkSamplerBorderColorComponentMappingCreateInfoEXT(vkb_enc *e, const VkSamplerBorderColorComponentMappingCreateInfoEXT *s); +void vkb_encfix_VkSamplerBorderColorComponentMappingCreateInfoEXT(vkb_enc *e, const VkSamplerBorderColorComponentMappingCreateInfoEXT *s, size_t raw); +void vkb_dec_VkSamplerBorderColorComponentMappingCreateInfoEXT(vkb_dec *d, VkSamplerBorderColorComponentMappingCreateInfoEXT *s); +void vkb_decfix_VkSamplerBorderColorComponentMappingCreateInfoEXT(vkb_dec *d, VkSamplerBorderColorComponentMappingCreateInfoEXT *s); +void vkb_enc_VkSamplerCreateInfo(vkb_enc *e, const VkSamplerCreateInfo *s); +void vkb_encfix_VkSamplerCreateInfo(vkb_enc *e, const VkSamplerCreateInfo *s, size_t raw); +void vkb_dec_VkSamplerCreateInfo(vkb_dec *d, VkSamplerCreateInfo *s); +void vkb_decfix_VkSamplerCreateInfo(vkb_dec *d, VkSamplerCreateInfo *s); +void vkb_enc_VkSamplerCustomBorderColorCreateInfoEXT(vkb_enc *e, const VkSamplerCustomBorderColorCreateInfoEXT *s); +void vkb_encfix_VkSamplerCustomBorderColorCreateInfoEXT(vkb_enc *e, const VkSamplerCustomBorderColorCreateInfoEXT *s, size_t raw); +void vkb_dec_VkSamplerCustomBorderColorCreateInfoEXT(vkb_dec *d, VkSamplerCustomBorderColorCreateInfoEXT *s); +void vkb_decfix_VkSamplerCustomBorderColorCreateInfoEXT(vkb_dec *d, VkSamplerCustomBorderColorCreateInfoEXT *s); +void vkb_enc_VkSamplerReductionModeCreateInfo(vkb_enc *e, const VkSamplerReductionModeCreateInfo *s); +void vkb_encfix_VkSamplerReductionModeCreateInfo(vkb_enc *e, const VkSamplerReductionModeCreateInfo *s, size_t raw); +void vkb_dec_VkSamplerReductionModeCreateInfo(vkb_dec *d, VkSamplerReductionModeCreateInfo *s); +void vkb_decfix_VkSamplerReductionModeCreateInfo(vkb_dec *d, VkSamplerReductionModeCreateInfo *s); +void vkb_enc_VkSamplerYcbcrConversionCreateInfo(vkb_enc *e, const VkSamplerYcbcrConversionCreateInfo *s); +void vkb_encfix_VkSamplerYcbcrConversionCreateInfo(vkb_enc *e, const VkSamplerYcbcrConversionCreateInfo *s, size_t raw); +void vkb_dec_VkSamplerYcbcrConversionCreateInfo(vkb_dec *d, VkSamplerYcbcrConversionCreateInfo *s); +void vkb_decfix_VkSamplerYcbcrConversionCreateInfo(vkb_dec *d, VkSamplerYcbcrConversionCreateInfo *s); +void vkb_enc_VkSamplerYcbcrConversionImageFormatProperties(vkb_enc *e, const VkSamplerYcbcrConversionImageFormatProperties *s); +void vkb_encfix_VkSamplerYcbcrConversionImageFormatProperties(vkb_enc *e, const VkSamplerYcbcrConversionImageFormatProperties *s, size_t raw); +void vkb_dec_VkSamplerYcbcrConversionImageFormatProperties(vkb_dec *d, VkSamplerYcbcrConversionImageFormatProperties *s); +void vkb_decfix_VkSamplerYcbcrConversionImageFormatProperties(vkb_dec *d, VkSamplerYcbcrConversionImageFormatProperties *s); +void vkb_enc_VkSamplerYcbcrConversionInfo(vkb_enc *e, const VkSamplerYcbcrConversionInfo *s); +void vkb_encfix_VkSamplerYcbcrConversionInfo(vkb_enc *e, const VkSamplerYcbcrConversionInfo *s, size_t raw); +void vkb_dec_VkSamplerYcbcrConversionInfo(vkb_dec *d, VkSamplerYcbcrConversionInfo *s); +void vkb_decfix_VkSamplerYcbcrConversionInfo(vkb_dec *d, VkSamplerYcbcrConversionInfo *s); +void vkb_enc_VkSemaphoreCreateInfo(vkb_enc *e, const VkSemaphoreCreateInfo *s); +void vkb_encfix_VkSemaphoreCreateInfo(vkb_enc *e, const VkSemaphoreCreateInfo *s, size_t raw); +void vkb_dec_VkSemaphoreCreateInfo(vkb_dec *d, VkSemaphoreCreateInfo *s); +void vkb_decfix_VkSemaphoreCreateInfo(vkb_dec *d, VkSemaphoreCreateInfo *s); +void vkb_enc_VkSemaphoreGetFdInfoKHR(vkb_enc *e, const VkSemaphoreGetFdInfoKHR *s); +void vkb_encfix_VkSemaphoreGetFdInfoKHR(vkb_enc *e, const VkSemaphoreGetFdInfoKHR *s, size_t raw); +void vkb_dec_VkSemaphoreGetFdInfoKHR(vkb_dec *d, VkSemaphoreGetFdInfoKHR *s); +void vkb_decfix_VkSemaphoreGetFdInfoKHR(vkb_dec *d, VkSemaphoreGetFdInfoKHR *s); +void vkb_enc_VkSemaphoreSignalInfo(vkb_enc *e, const VkSemaphoreSignalInfo *s); +void vkb_encfix_VkSemaphoreSignalInfo(vkb_enc *e, const VkSemaphoreSignalInfo *s, size_t raw); +void vkb_dec_VkSemaphoreSignalInfo(vkb_dec *d, VkSemaphoreSignalInfo *s); +void vkb_decfix_VkSemaphoreSignalInfo(vkb_dec *d, VkSemaphoreSignalInfo *s); +void vkb_enc_VkSemaphoreSubmitInfo(vkb_enc *e, const VkSemaphoreSubmitInfo *s); +void vkb_encfix_VkSemaphoreSubmitInfo(vkb_enc *e, const VkSemaphoreSubmitInfo *s, size_t raw); +void vkb_dec_VkSemaphoreSubmitInfo(vkb_dec *d, VkSemaphoreSubmitInfo *s); +void vkb_decfix_VkSemaphoreSubmitInfo(vkb_dec *d, VkSemaphoreSubmitInfo *s); +void vkb_enc_VkSemaphoreTypeCreateInfo(vkb_enc *e, const VkSemaphoreTypeCreateInfo *s); +void vkb_encfix_VkSemaphoreTypeCreateInfo(vkb_enc *e, const VkSemaphoreTypeCreateInfo *s, size_t raw); +void vkb_dec_VkSemaphoreTypeCreateInfo(vkb_dec *d, VkSemaphoreTypeCreateInfo *s); +void vkb_decfix_VkSemaphoreTypeCreateInfo(vkb_dec *d, VkSemaphoreTypeCreateInfo *s); +void vkb_enc_VkSemaphoreWaitInfo(vkb_enc *e, const VkSemaphoreWaitInfo *s); +void vkb_encfix_VkSemaphoreWaitInfo(vkb_enc *e, const VkSemaphoreWaitInfo *s, size_t raw); +void vkb_dec_VkSemaphoreWaitInfo(vkb_dec *d, VkSemaphoreWaitInfo *s); +void vkb_decfix_VkSemaphoreWaitInfo(vkb_dec *d, VkSemaphoreWaitInfo *s); +void vkb_enc_VkShaderModuleCreateInfo(vkb_enc *e, const VkShaderModuleCreateInfo *s); +void vkb_encfix_VkShaderModuleCreateInfo(vkb_enc *e, const VkShaderModuleCreateInfo *s, size_t raw); +void vkb_dec_VkShaderModuleCreateInfo(vkb_dec *d, VkShaderModuleCreateInfo *s); +void vkb_decfix_VkShaderModuleCreateInfo(vkb_dec *d, VkShaderModuleCreateInfo *s); +void vkb_enc_VkShaderModuleIdentifierEXT(vkb_enc *e, const VkShaderModuleIdentifierEXT *s); +void vkb_encfix_VkShaderModuleIdentifierEXT(vkb_enc *e, const VkShaderModuleIdentifierEXT *s, size_t raw); +void vkb_dec_VkShaderModuleIdentifierEXT(vkb_dec *d, VkShaderModuleIdentifierEXT *s); +void vkb_decfix_VkShaderModuleIdentifierEXT(vkb_dec *d, VkShaderModuleIdentifierEXT *s); +void vkb_enc_VkSparseBufferMemoryBindInfo(vkb_enc *e, const VkSparseBufferMemoryBindInfo *s); +void vkb_encfix_VkSparseBufferMemoryBindInfo(vkb_enc *e, const VkSparseBufferMemoryBindInfo *s, size_t raw); +void vkb_dec_VkSparseBufferMemoryBindInfo(vkb_dec *d, VkSparseBufferMemoryBindInfo *s); +void vkb_decfix_VkSparseBufferMemoryBindInfo(vkb_dec *d, VkSparseBufferMemoryBindInfo *s); +void vkb_enc_VkSparseImageFormatProperties2(vkb_enc *e, const VkSparseImageFormatProperties2 *s); +void vkb_encfix_VkSparseImageFormatProperties2(vkb_enc *e, const VkSparseImageFormatProperties2 *s, size_t raw); +void vkb_dec_VkSparseImageFormatProperties2(vkb_dec *d, VkSparseImageFormatProperties2 *s); +void vkb_decfix_VkSparseImageFormatProperties2(vkb_dec *d, VkSparseImageFormatProperties2 *s); +void vkb_enc_VkSparseImageMemoryBindInfo(vkb_enc *e, const VkSparseImageMemoryBindInfo *s); +void vkb_encfix_VkSparseImageMemoryBindInfo(vkb_enc *e, const VkSparseImageMemoryBindInfo *s, size_t raw); +void vkb_dec_VkSparseImageMemoryBindInfo(vkb_dec *d, VkSparseImageMemoryBindInfo *s); +void vkb_decfix_VkSparseImageMemoryBindInfo(vkb_dec *d, VkSparseImageMemoryBindInfo *s); +void vkb_enc_VkSparseImageMemoryRequirements2(vkb_enc *e, const VkSparseImageMemoryRequirements2 *s); +void vkb_encfix_VkSparseImageMemoryRequirements2(vkb_enc *e, const VkSparseImageMemoryRequirements2 *s, size_t raw); +void vkb_dec_VkSparseImageMemoryRequirements2(vkb_dec *d, VkSparseImageMemoryRequirements2 *s); +void vkb_decfix_VkSparseImageMemoryRequirements2(vkb_dec *d, VkSparseImageMemoryRequirements2 *s); +void vkb_enc_VkSparseImageOpaqueMemoryBindInfo(vkb_enc *e, const VkSparseImageOpaqueMemoryBindInfo *s); +void vkb_encfix_VkSparseImageOpaqueMemoryBindInfo(vkb_enc *e, const VkSparseImageOpaqueMemoryBindInfo *s, size_t raw); +void vkb_dec_VkSparseImageOpaqueMemoryBindInfo(vkb_dec *d, VkSparseImageOpaqueMemoryBindInfo *s); +void vkb_decfix_VkSparseImageOpaqueMemoryBindInfo(vkb_dec *d, VkSparseImageOpaqueMemoryBindInfo *s); +void vkb_enc_VkSpecializationInfo(vkb_enc *e, const VkSpecializationInfo *s); +void vkb_encfix_VkSpecializationInfo(vkb_enc *e, const VkSpecializationInfo *s, size_t raw); +void vkb_dec_VkSpecializationInfo(vkb_dec *d, VkSpecializationInfo *s); +void vkb_decfix_VkSpecializationInfo(vkb_dec *d, VkSpecializationInfo *s); +void vkb_enc_VkSubmitInfo(vkb_enc *e, const VkSubmitInfo *s); +void vkb_encfix_VkSubmitInfo(vkb_enc *e, const VkSubmitInfo *s, size_t raw); +void vkb_dec_VkSubmitInfo(vkb_dec *d, VkSubmitInfo *s); +void vkb_decfix_VkSubmitInfo(vkb_dec *d, VkSubmitInfo *s); +void vkb_enc_VkSubmitInfo2(vkb_enc *e, const VkSubmitInfo2 *s); +void vkb_encfix_VkSubmitInfo2(vkb_enc *e, const VkSubmitInfo2 *s, size_t raw); +void vkb_dec_VkSubmitInfo2(vkb_dec *d, VkSubmitInfo2 *s); +void vkb_decfix_VkSubmitInfo2(vkb_dec *d, VkSubmitInfo2 *s); +void vkb_enc_VkSubpassBeginInfo(vkb_enc *e, const VkSubpassBeginInfo *s); +void vkb_encfix_VkSubpassBeginInfo(vkb_enc *e, const VkSubpassBeginInfo *s, size_t raw); +void vkb_dec_VkSubpassBeginInfo(vkb_dec *d, VkSubpassBeginInfo *s); +void vkb_decfix_VkSubpassBeginInfo(vkb_dec *d, VkSubpassBeginInfo *s); +void vkb_enc_VkSubpassDependency2(vkb_enc *e, const VkSubpassDependency2 *s); +void vkb_encfix_VkSubpassDependency2(vkb_enc *e, const VkSubpassDependency2 *s, size_t raw); +void vkb_dec_VkSubpassDependency2(vkb_dec *d, VkSubpassDependency2 *s); +void vkb_decfix_VkSubpassDependency2(vkb_dec *d, VkSubpassDependency2 *s); +void vkb_enc_VkSubpassDescription(vkb_enc *e, const VkSubpassDescription *s); +void vkb_encfix_VkSubpassDescription(vkb_enc *e, const VkSubpassDescription *s, size_t raw); +void vkb_dec_VkSubpassDescription(vkb_dec *d, VkSubpassDescription *s); +void vkb_decfix_VkSubpassDescription(vkb_dec *d, VkSubpassDescription *s); +void vkb_enc_VkSubpassDescription2(vkb_enc *e, const VkSubpassDescription2 *s); +void vkb_encfix_VkSubpassDescription2(vkb_enc *e, const VkSubpassDescription2 *s, size_t raw); +void vkb_dec_VkSubpassDescription2(vkb_dec *d, VkSubpassDescription2 *s); +void vkb_decfix_VkSubpassDescription2(vkb_dec *d, VkSubpassDescription2 *s); +void vkb_enc_VkSubpassDescriptionDepthStencilResolve(vkb_enc *e, const VkSubpassDescriptionDepthStencilResolve *s); +void vkb_encfix_VkSubpassDescriptionDepthStencilResolve(vkb_enc *e, const VkSubpassDescriptionDepthStencilResolve *s, size_t raw); +void vkb_dec_VkSubpassDescriptionDepthStencilResolve(vkb_dec *d, VkSubpassDescriptionDepthStencilResolve *s); +void vkb_decfix_VkSubpassDescriptionDepthStencilResolve(vkb_dec *d, VkSubpassDescriptionDepthStencilResolve *s); +void vkb_enc_VkSubpassEndInfo(vkb_enc *e, const VkSubpassEndInfo *s); +void vkb_encfix_VkSubpassEndInfo(vkb_enc *e, const VkSubpassEndInfo *s, size_t raw); +void vkb_dec_VkSubpassEndInfo(vkb_dec *d, VkSubpassEndInfo *s); +void vkb_decfix_VkSubpassEndInfo(vkb_dec *d, VkSubpassEndInfo *s); +void vkb_enc_VkSubpassResolvePerformanceQueryEXT(vkb_enc *e, const VkSubpassResolvePerformanceQueryEXT *s); +void vkb_encfix_VkSubpassResolvePerformanceQueryEXT(vkb_enc *e, const VkSubpassResolvePerformanceQueryEXT *s, size_t raw); +void vkb_dec_VkSubpassResolvePerformanceQueryEXT(vkb_dec *d, VkSubpassResolvePerformanceQueryEXT *s); +void vkb_decfix_VkSubpassResolvePerformanceQueryEXT(vkb_dec *d, VkSubpassResolvePerformanceQueryEXT *s); +void vkb_enc_VkSubpassSampleLocationsEXT(vkb_enc *e, const VkSubpassSampleLocationsEXT *s); +void vkb_encfix_VkSubpassSampleLocationsEXT(vkb_enc *e, const VkSubpassSampleLocationsEXT *s, size_t raw); +void vkb_dec_VkSubpassSampleLocationsEXT(vkb_dec *d, VkSubpassSampleLocationsEXT *s); +void vkb_decfix_VkSubpassSampleLocationsEXT(vkb_dec *d, VkSubpassSampleLocationsEXT *s); +void vkb_enc_VkSubresourceLayout2EXT(vkb_enc *e, const VkSubresourceLayout2EXT *s); +void vkb_encfix_VkSubresourceLayout2EXT(vkb_enc *e, const VkSubresourceLayout2EXT *s, size_t raw); +void vkb_dec_VkSubresourceLayout2EXT(vkb_dec *d, VkSubresourceLayout2EXT *s); +void vkb_decfix_VkSubresourceLayout2EXT(vkb_dec *d, VkSubresourceLayout2EXT *s); +void vkb_enc_VkTimelineSemaphoreSubmitInfo(vkb_enc *e, const VkTimelineSemaphoreSubmitInfo *s); +void vkb_encfix_VkTimelineSemaphoreSubmitInfo(vkb_enc *e, const VkTimelineSemaphoreSubmitInfo *s, size_t raw); +void vkb_dec_VkTimelineSemaphoreSubmitInfo(vkb_dec *d, VkTimelineSemaphoreSubmitInfo *s); +void vkb_decfix_VkTimelineSemaphoreSubmitInfo(vkb_dec *d, VkTimelineSemaphoreSubmitInfo *s); +void vkb_enc_VkVertexInputAttributeDescription2EXT(vkb_enc *e, const VkVertexInputAttributeDescription2EXT *s); +void vkb_encfix_VkVertexInputAttributeDescription2EXT(vkb_enc *e, const VkVertexInputAttributeDescription2EXT *s, size_t raw); +void vkb_dec_VkVertexInputAttributeDescription2EXT(vkb_dec *d, VkVertexInputAttributeDescription2EXT *s); +void vkb_decfix_VkVertexInputAttributeDescription2EXT(vkb_dec *d, VkVertexInputAttributeDescription2EXT *s); +void vkb_enc_VkVertexInputBindingDescription2EXT(vkb_enc *e, const VkVertexInputBindingDescription2EXT *s); +void vkb_encfix_VkVertexInputBindingDescription2EXT(vkb_enc *e, const VkVertexInputBindingDescription2EXT *s, size_t raw); +void vkb_dec_VkVertexInputBindingDescription2EXT(vkb_dec *d, VkVertexInputBindingDescription2EXT *s); +void vkb_decfix_VkVertexInputBindingDescription2EXT(vkb_dec *d, VkVertexInputBindingDescription2EXT *s); +void vkb_enc_VkWriteDescriptorSet(vkb_enc *e, const VkWriteDescriptorSet *s); +void vkb_encfix_VkWriteDescriptorSet(vkb_enc *e, const VkWriteDescriptorSet *s, size_t raw); +void vkb_dec_VkWriteDescriptorSet(vkb_dec *d, VkWriteDescriptorSet *s); +void vkb_decfix_VkWriteDescriptorSet(vkb_dec *d, VkWriteDescriptorSet *s); +void vkb_enc_VkWriteDescriptorSetInlineUniformBlock(vkb_enc *e, const VkWriteDescriptorSetInlineUniformBlock *s); +void vkb_encfix_VkWriteDescriptorSetInlineUniformBlock(vkb_enc *e, const VkWriteDescriptorSetInlineUniformBlock *s, size_t raw); +void vkb_dec_VkWriteDescriptorSetInlineUniformBlock(vkb_dec *d, VkWriteDescriptorSetInlineUniformBlock *s); +void vkb_decfix_VkWriteDescriptorSetInlineUniformBlock(vkb_dec *d, VkWriteDescriptorSetInlineUniformBlock *s); + +/* Bridged extensions: name, 1 = device, client-implemented flag. */ +typedef struct vkb_ext_desc { const char *name; uint8_t device; uint8_t client; } vkb_ext_desc; +#define VKB_EXT_COUNT 169 +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; +#define VKB_LEVEL_GLOBAL 0 +#define VKB_LEVEL_INSTANCE 1 +#define VKB_LEVEL_PHYSDEV 2 +#define VKB_LEVEL_DEVICE 3 +extern const vkb_proc_desc vkb_client_procs[]; +extern const size_t vkb_client_proc_count; + +#endif diff --git a/tools/vkbridge/common/gen/vkb_gen_client.c b/tools/vkbridge/common/gen/vkb_gen_client.c new file mode 100644 index 000000000..6414be2f6 --- /dev/null +++ b/tools/vkbridge/common/gen/vkb_gen_client.c @@ -0,0 +1,6735 @@ +/* Generated by tools/vkbridge/codegen/gen_vkbridge.py from vk.xml 1.3.247 - do not edit. */ + +#include "vkb_gen.h" +#include "vkb_client_gen.h" +#include "../vkb_wire.h" +#include "../../client/vkb_client.h" +#include + +VkResult vkb_wire_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkAllocateCommandBuffers, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pAllocateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkCommandBufferAllocateInfo(e, &pAllocateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + { uint32_t n_ = pCommandBuffers ? (uint32_t)(pAllocateInfo->commandBufferCount) : 0; + vkb_enc_u8(e, pCommandBuffers != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = pCommandBuffers ? (uint32_t)(pAllocateInfo->commandBufferCount) : 0; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + pCommandBuffers[i_] = (VkCommandBuffer)vkb_wrap(VK_OBJECT_TYPE_COMMAND_BUFFER, (const void *)device, vkb_dec_u64(d)); + } + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkAllocateDescriptorSets, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pAllocateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDescriptorSetAllocateInfo(e, &pAllocateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + { uint32_t n_ = pDescriptorSets ? (uint32_t)(pAllocateInfo->descriptorSetCount) : 0; + vkb_enc_u8(e, pDescriptorSets != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = pDescriptorSets ? (uint32_t)(pAllocateInfo->descriptorSetCount) : 0; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_raw_into(d, &pDescriptorSets[i_], sizeof(VkDescriptorSet)); + } + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkAllocateMemory, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pAllocateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkMemoryAllocateInfo(e, &pAllocateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pMemory != NULL); + if (pMemory) vkb_enc_bytes(e, pMemory, sizeof(*pMemory)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pMemory) vkb_dec_raw_into(d, pMemory, sizeof(*pMemory)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkBeginCommandBuffer, vkb_table_of((const void *)commandBuffer)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pBeginInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkCommandBufferBeginInfo(e, &pBeginInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkBindBufferMemory, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &buffer, sizeof(buffer)); + vkb_enc_bytes(e, &memory, sizeof(memory)); + vkb_enc_bytes(e, &memoryOffset, sizeof(memoryOffset)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkBindBufferMemory2, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &bindInfoCount, sizeof(bindInfoCount)); + if (pBindInfos) { + uint32_t n_ = (uint32_t)(bindInfoCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBindBufferMemoryInfo(e, &pBindInfos[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkBindImageMemory, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &image, sizeof(image)); + vkb_enc_bytes(e, &memory, sizeof(memory)); + vkb_enc_bytes(e, &memoryOffset, sizeof(memoryOffset)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkBindImageMemory2, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &bindInfoCount, sizeof(bindInfoCount)); + if (pBindInfos) { + uint32_t n_ = (uint32_t)(bindInfoCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBindImageMemoryInfo(e, &pBindInfos[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBeginConditionalRenderingEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pConditionalRenderingBegin) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkConditionalRenderingBeginInfoEXT(e, &pConditionalRenderingBegin[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBeginQuery); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &queryPool, sizeof(queryPool)); + vkb_enc_bytes(e, &query, sizeof(query)); + vkb_enc_bytes(e, &flags, sizeof(flags)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBeginQueryIndexedEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &queryPool, sizeof(queryPool)); + vkb_enc_bytes(e, &query, sizeof(query)); + vkb_enc_bytes(e, &flags, sizeof(flags)); + vkb_enc_bytes(e, &index, sizeof(index)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBeginRenderPass); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pRenderPassBegin) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkRenderPassBeginInfo(e, &pRenderPassBegin[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &contents, sizeof(contents)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBeginRenderPass2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pRenderPassBegin) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkRenderPassBeginInfo(e, &pRenderPassBegin[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (pSubpassBeginInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSubpassBeginInfo(e, &pSubpassBeginInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBeginRendering); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pRenderingInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkRenderingInfo(e, &pRenderingInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBeginTransformFeedbackEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstCounterBuffer, sizeof(firstCounterBuffer)); + vkb_enc_bytes(e, &counterBufferCount, sizeof(counterBufferCount)); + if (pCounterBuffers) { + uint32_t n_ = (uint32_t)(counterBufferCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pCounterBuffers, (size_t)n_ * sizeof(*pCounterBuffers)); + } else { + vkb_enc_u8(e, 0); + } + if (pCounterBufferOffsets) { + uint32_t n_ = (uint32_t)(counterBufferCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pCounterBufferOffsets, (size_t)n_ * sizeof(*pCounterBufferOffsets)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBindDescriptorSets); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &pipelineBindPoint, sizeof(pipelineBindPoint)); + vkb_enc_bytes(e, &layout, sizeof(layout)); + vkb_enc_bytes(e, &firstSet, sizeof(firstSet)); + vkb_enc_bytes(e, &descriptorSetCount, sizeof(descriptorSetCount)); + if (pDescriptorSets) { + uint32_t n_ = (uint32_t)(descriptorSetCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pDescriptorSets, (size_t)n_ * sizeof(*pDescriptorSets)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &dynamicOffsetCount, sizeof(dynamicOffsetCount)); + if (pDynamicOffsets) { + uint32_t n_ = (uint32_t)(dynamicOffsetCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pDynamicOffsets, (size_t)n_ * sizeof(*pDynamicOffsets)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBindIndexBuffer); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &buffer, sizeof(buffer)); + vkb_enc_bytes(e, &offset, sizeof(offset)); + vkb_enc_bytes(e, &indexType, sizeof(indexType)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBindPipeline); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &pipelineBindPoint, sizeof(pipelineBindPoint)); + vkb_enc_bytes(e, &pipeline, sizeof(pipeline)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBindTransformFeedbackBuffersEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstBinding, sizeof(firstBinding)); + vkb_enc_bytes(e, &bindingCount, sizeof(bindingCount)); + if (pBuffers) { + uint32_t n_ = (uint32_t)(bindingCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pBuffers, (size_t)n_ * sizeof(*pBuffers)); + } else { + vkb_enc_u8(e, 0); + } + if (pOffsets) { + uint32_t n_ = (uint32_t)(bindingCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pOffsets, (size_t)n_ * sizeof(*pOffsets)); + } else { + vkb_enc_u8(e, 0); + } + if (pSizes) { + uint32_t n_ = (uint32_t)(bindingCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pSizes, (size_t)n_ * sizeof(*pSizes)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBindVertexBuffers); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstBinding, sizeof(firstBinding)); + vkb_enc_bytes(e, &bindingCount, sizeof(bindingCount)); + if (pBuffers) { + uint32_t n_ = (uint32_t)(bindingCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pBuffers, (size_t)n_ * sizeof(*pBuffers)); + } else { + vkb_enc_u8(e, 0); + } + if (pOffsets) { + uint32_t n_ = (uint32_t)(bindingCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pOffsets, (size_t)n_ * sizeof(*pOffsets)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBindVertexBuffers2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstBinding, sizeof(firstBinding)); + vkb_enc_bytes(e, &bindingCount, sizeof(bindingCount)); + if (pBuffers) { + uint32_t n_ = (uint32_t)(bindingCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pBuffers, (size_t)n_ * sizeof(*pBuffers)); + } else { + vkb_enc_u8(e, 0); + } + if (pOffsets) { + uint32_t n_ = (uint32_t)(bindingCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pOffsets, (size_t)n_ * sizeof(*pOffsets)); + } else { + vkb_enc_u8(e, 0); + } + if (pSizes) { + uint32_t n_ = (uint32_t)(bindingCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pSizes, (size_t)n_ * sizeof(*pSizes)); + } else { + vkb_enc_u8(e, 0); + } + if (pStrides) { + uint32_t n_ = (uint32_t)(bindingCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pStrides, (size_t)n_ * sizeof(*pStrides)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBlitImage); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &srcImage, sizeof(srcImage)); + vkb_enc_bytes(e, &srcImageLayout, sizeof(srcImageLayout)); + vkb_enc_bytes(e, &dstImage, sizeof(dstImage)); + vkb_enc_bytes(e, &dstImageLayout, sizeof(dstImageLayout)); + vkb_enc_bytes(e, ®ionCount, sizeof(regionCount)); + if (pRegions) { + uint32_t n_ = (uint32_t)(regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pRegions, (size_t)n_ * sizeof(*pRegions)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &filter, sizeof(filter)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBlitImage2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pBlitImageInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBlitImageInfo2(e, &pBlitImageInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdClearAttachments); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &attachmentCount, sizeof(attachmentCount)); + if (pAttachments) { + uint32_t n_ = (uint32_t)(attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pAttachments, (size_t)n_ * sizeof(*pAttachments)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &rectCount, sizeof(rectCount)); + if (pRects) { + uint32_t n_ = (uint32_t)(rectCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pRects, (size_t)n_ * sizeof(*pRects)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdClearColorImage); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &image, sizeof(image)); + vkb_enc_bytes(e, &imageLayout, sizeof(imageLayout)); + if (pColor) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pColor, (size_t)n_ * sizeof(*pColor)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &rangeCount, sizeof(rangeCount)); + if (pRanges) { + uint32_t n_ = (uint32_t)(rangeCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pRanges, (size_t)n_ * sizeof(*pRanges)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdClearDepthStencilImage); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &image, sizeof(image)); + vkb_enc_bytes(e, &imageLayout, sizeof(imageLayout)); + if (pDepthStencil) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pDepthStencil, (size_t)n_ * sizeof(*pDepthStencil)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &rangeCount, sizeof(rangeCount)); + if (pRanges) { + uint32_t n_ = (uint32_t)(rangeCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pRanges, (size_t)n_ * sizeof(*pRanges)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdCopyBuffer); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &srcBuffer, sizeof(srcBuffer)); + vkb_enc_bytes(e, &dstBuffer, sizeof(dstBuffer)); + vkb_enc_bytes(e, ®ionCount, sizeof(regionCount)); + if (pRegions) { + uint32_t n_ = (uint32_t)(regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pRegions, (size_t)n_ * sizeof(*pRegions)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdCopyBuffer2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pCopyBufferInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkCopyBufferInfo2(e, &pCopyBufferInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdCopyBufferToImage); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &srcBuffer, sizeof(srcBuffer)); + vkb_enc_bytes(e, &dstImage, sizeof(dstImage)); + vkb_enc_bytes(e, &dstImageLayout, sizeof(dstImageLayout)); + vkb_enc_bytes(e, ®ionCount, sizeof(regionCount)); + if (pRegions) { + uint32_t n_ = (uint32_t)(regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pRegions, (size_t)n_ * sizeof(*pRegions)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdCopyBufferToImage2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pCopyBufferToImageInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkCopyBufferToImageInfo2(e, &pCopyBufferToImageInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdCopyImage); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &srcImage, sizeof(srcImage)); + vkb_enc_bytes(e, &srcImageLayout, sizeof(srcImageLayout)); + vkb_enc_bytes(e, &dstImage, sizeof(dstImage)); + vkb_enc_bytes(e, &dstImageLayout, sizeof(dstImageLayout)); + vkb_enc_bytes(e, ®ionCount, sizeof(regionCount)); + if (pRegions) { + uint32_t n_ = (uint32_t)(regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pRegions, (size_t)n_ * sizeof(*pRegions)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdCopyImage2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pCopyImageInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkCopyImageInfo2(e, &pCopyImageInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdCopyImageToBuffer); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &srcImage, sizeof(srcImage)); + vkb_enc_bytes(e, &srcImageLayout, sizeof(srcImageLayout)); + vkb_enc_bytes(e, &dstBuffer, sizeof(dstBuffer)); + vkb_enc_bytes(e, ®ionCount, sizeof(regionCount)); + if (pRegions) { + uint32_t n_ = (uint32_t)(regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pRegions, (size_t)n_ * sizeof(*pRegions)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdCopyImageToBuffer2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pCopyImageToBufferInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkCopyImageToBufferInfo2(e, &pCopyImageToBufferInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdCopyQueryPoolResults); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &queryPool, sizeof(queryPool)); + vkb_enc_bytes(e, &firstQuery, sizeof(firstQuery)); + vkb_enc_bytes(e, &queryCount, sizeof(queryCount)); + vkb_enc_bytes(e, &dstBuffer, sizeof(dstBuffer)); + vkb_enc_bytes(e, &dstOffset, sizeof(dstOffset)); + vkb_enc_bytes(e, &stride, sizeof(stride)); + vkb_enc_bytes(e, &flags, sizeof(flags)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDispatch); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &groupCountX, sizeof(groupCountX)); + vkb_enc_bytes(e, &groupCountY, sizeof(groupCountY)); + vkb_enc_bytes(e, &groupCountZ, sizeof(groupCountZ)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDispatchBase); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &baseGroupX, sizeof(baseGroupX)); + vkb_enc_bytes(e, &baseGroupY, sizeof(baseGroupY)); + vkb_enc_bytes(e, &baseGroupZ, sizeof(baseGroupZ)); + vkb_enc_bytes(e, &groupCountX, sizeof(groupCountX)); + vkb_enc_bytes(e, &groupCountY, sizeof(groupCountY)); + vkb_enc_bytes(e, &groupCountZ, sizeof(groupCountZ)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDispatchIndirect); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &buffer, sizeof(buffer)); + vkb_enc_bytes(e, &offset, sizeof(offset)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDraw); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &vertexCount, sizeof(vertexCount)); + vkb_enc_bytes(e, &instanceCount, sizeof(instanceCount)); + vkb_enc_bytes(e, &firstVertex, sizeof(firstVertex)); + vkb_enc_bytes(e, &firstInstance, sizeof(firstInstance)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDrawIndexed); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &indexCount, sizeof(indexCount)); + vkb_enc_bytes(e, &instanceCount, sizeof(instanceCount)); + vkb_enc_bytes(e, &firstIndex, sizeof(firstIndex)); + vkb_enc_bytes(e, &vertexOffset, sizeof(vertexOffset)); + vkb_enc_bytes(e, &firstInstance, sizeof(firstInstance)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDrawIndexedIndirect); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &buffer, sizeof(buffer)); + vkb_enc_bytes(e, &offset, sizeof(offset)); + vkb_enc_bytes(e, &drawCount, sizeof(drawCount)); + vkb_enc_bytes(e, &stride, sizeof(stride)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDrawIndexedIndirectCount); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &buffer, sizeof(buffer)); + vkb_enc_bytes(e, &offset, sizeof(offset)); + vkb_enc_bytes(e, &countBuffer, sizeof(countBuffer)); + vkb_enc_bytes(e, &countBufferOffset, sizeof(countBufferOffset)); + vkb_enc_bytes(e, &maxDrawCount, sizeof(maxDrawCount)); + vkb_enc_bytes(e, &stride, sizeof(stride)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDrawIndirect); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &buffer, sizeof(buffer)); + vkb_enc_bytes(e, &offset, sizeof(offset)); + vkb_enc_bytes(e, &drawCount, sizeof(drawCount)); + vkb_enc_bytes(e, &stride, sizeof(stride)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDrawIndirectByteCountEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &instanceCount, sizeof(instanceCount)); + vkb_enc_bytes(e, &firstInstance, sizeof(firstInstance)); + vkb_enc_bytes(e, &counterBuffer, sizeof(counterBuffer)); + vkb_enc_bytes(e, &counterBufferOffset, sizeof(counterBufferOffset)); + vkb_enc_bytes(e, &counterOffset, sizeof(counterOffset)); + vkb_enc_bytes(e, &vertexStride, sizeof(vertexStride)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDrawIndirectCount); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &buffer, sizeof(buffer)); + vkb_enc_bytes(e, &offset, sizeof(offset)); + vkb_enc_bytes(e, &countBuffer, sizeof(countBuffer)); + vkb_enc_bytes(e, &countBufferOffset, sizeof(countBufferOffset)); + vkb_enc_bytes(e, &maxDrawCount, sizeof(maxDrawCount)); + vkb_enc_bytes(e, &stride, sizeof(stride)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDrawMultiEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &drawCount, sizeof(drawCount)); + if (pVertexInfo) { + uint32_t n_ = (uint32_t)(drawCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pVertexInfo, (size_t)n_ * sizeof(*pVertexInfo)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &instanceCount, sizeof(instanceCount)); + vkb_enc_bytes(e, &firstInstance, sizeof(firstInstance)); + vkb_enc_bytes(e, &stride, sizeof(stride)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdDrawMultiIndexedEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &drawCount, sizeof(drawCount)); + if (pIndexInfo) { + uint32_t n_ = (uint32_t)(drawCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pIndexInfo, (size_t)n_ * sizeof(*pIndexInfo)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &instanceCount, sizeof(instanceCount)); + vkb_enc_bytes(e, &firstInstance, sizeof(firstInstance)); + vkb_enc_bytes(e, &stride, sizeof(stride)); + if (pVertexOffset) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pVertexOffset, (size_t)n_ * sizeof(*pVertexOffset)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdEndConditionalRenderingEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdEndQuery); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &queryPool, sizeof(queryPool)); + vkb_enc_bytes(e, &query, sizeof(query)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdEndQueryIndexedEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &queryPool, sizeof(queryPool)); + vkb_enc_bytes(e, &query, sizeof(query)); + vkb_enc_bytes(e, &index, sizeof(index)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdEndRenderPass); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdEndRenderPass2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pSubpassEndInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSubpassEndInfo(e, &pSubpassEndInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdEndRendering(VkCommandBuffer commandBuffer) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdEndRendering); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdEndTransformFeedbackEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstCounterBuffer, sizeof(firstCounterBuffer)); + vkb_enc_bytes(e, &counterBufferCount, sizeof(counterBufferCount)); + if (pCounterBuffers) { + uint32_t n_ = (uint32_t)(counterBufferCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pCounterBuffers, (size_t)n_ * sizeof(*pCounterBuffers)); + } else { + vkb_enc_u8(e, 0); + } + if (pCounterBufferOffsets) { + uint32_t n_ = (uint32_t)(counterBufferCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pCounterBufferOffsets, (size_t)n_ * sizeof(*pCounterBufferOffsets)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdExecuteCommands); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &commandBufferCount, sizeof(commandBufferCount)); + if (pCommandBuffers) { + uint32_t n_ = (uint32_t)(commandBufferCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_u64(e, vkb_remote((const void *)pCommandBuffers[i_])); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdFillBuffer); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &dstBuffer, sizeof(dstBuffer)); + vkb_enc_bytes(e, &dstOffset, sizeof(dstOffset)); + vkb_enc_bytes(e, &size, sizeof(size)); + vkb_enc_bytes(e, &data, sizeof(data)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdNextSubpass); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &contents, sizeof(contents)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdNextSubpass2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pSubpassBeginInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSubpassBeginInfo(e, &pSubpassBeginInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (pSubpassEndInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSubpassEndInfo(e, &pSubpassEndInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdPipelineBarrier); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &srcStageMask, sizeof(srcStageMask)); + vkb_enc_bytes(e, &dstStageMask, sizeof(dstStageMask)); + vkb_enc_bytes(e, &dependencyFlags, sizeof(dependencyFlags)); + vkb_enc_bytes(e, &memoryBarrierCount, sizeof(memoryBarrierCount)); + if (pMemoryBarriers) { + uint32_t n_ = (uint32_t)(memoryBarrierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkMemoryBarrier(e, &pMemoryBarriers[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &bufferMemoryBarrierCount, sizeof(bufferMemoryBarrierCount)); + if (pBufferMemoryBarriers) { + uint32_t n_ = (uint32_t)(bufferMemoryBarrierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferMemoryBarrier(e, &pBufferMemoryBarriers[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &imageMemoryBarrierCount, sizeof(imageMemoryBarrierCount)); + if (pImageMemoryBarriers) { + uint32_t n_ = (uint32_t)(imageMemoryBarrierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageMemoryBarrier(e, &pImageMemoryBarriers[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdPipelineBarrier2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pDependencyInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDependencyInfo(e, &pDependencyInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdPushConstants); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &layout, sizeof(layout)); + vkb_enc_bytes(e, &stageFlags, sizeof(stageFlags)); + vkb_enc_bytes(e, &offset, sizeof(offset)); + vkb_enc_bytes(e, &size, sizeof(size)); + vkb_enc_blob(e, pValues ? (const void *)pValues : NULL, pValues ? (size_t)(size) : 0); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdPushDescriptorSetKHR); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &pipelineBindPoint, sizeof(pipelineBindPoint)); + vkb_enc_bytes(e, &layout, sizeof(layout)); + vkb_enc_bytes(e, &set, sizeof(set)); + vkb_enc_bytes(e, &descriptorWriteCount, sizeof(descriptorWriteCount)); + if (pDescriptorWrites) { + uint32_t n_ = (uint32_t)(descriptorWriteCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkWriteDescriptorSet(e, &pDescriptorWrites[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdResetEvent); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &event, sizeof(event)); + vkb_enc_bytes(e, &stageMask, sizeof(stageMask)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdResetEvent2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &event, sizeof(event)); + vkb_enc_bytes(e, &stageMask, sizeof(stageMask)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdResetQueryPool); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &queryPool, sizeof(queryPool)); + vkb_enc_bytes(e, &firstQuery, sizeof(firstQuery)); + vkb_enc_bytes(e, &queryCount, sizeof(queryCount)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdResolveImage); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &srcImage, sizeof(srcImage)); + vkb_enc_bytes(e, &srcImageLayout, sizeof(srcImageLayout)); + vkb_enc_bytes(e, &dstImage, sizeof(dstImage)); + vkb_enc_bytes(e, &dstImageLayout, sizeof(dstImageLayout)); + vkb_enc_bytes(e, ®ionCount, sizeof(regionCount)); + if (pRegions) { + uint32_t n_ = (uint32_t)(regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pRegions, (size_t)n_ * sizeof(*pRegions)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdResolveImage2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pResolveImageInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkResolveImageInfo2(e, &pResolveImageInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetAlphaToCoverageEnableEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &alphaToCoverageEnable, sizeof(alphaToCoverageEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetAlphaToOneEnableEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &alphaToOneEnable, sizeof(alphaToOneEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetBlendConstants); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_raw(e, blendConstants, sizeof(float) * 4); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetColorBlendAdvancedEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstAttachment, sizeof(firstAttachment)); + vkb_enc_bytes(e, &attachmentCount, sizeof(attachmentCount)); + if (pColorBlendAdvanced) { + uint32_t n_ = (uint32_t)(attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pColorBlendAdvanced, (size_t)n_ * sizeof(*pColorBlendAdvanced)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetColorBlendEnableEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstAttachment, sizeof(firstAttachment)); + vkb_enc_bytes(e, &attachmentCount, sizeof(attachmentCount)); + if (pColorBlendEnables) { + uint32_t n_ = (uint32_t)(attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pColorBlendEnables, (size_t)n_ * sizeof(*pColorBlendEnables)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetColorBlendEquationEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstAttachment, sizeof(firstAttachment)); + vkb_enc_bytes(e, &attachmentCount, sizeof(attachmentCount)); + if (pColorBlendEquations) { + uint32_t n_ = (uint32_t)(attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pColorBlendEquations, (size_t)n_ * sizeof(*pColorBlendEquations)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetColorWriteEnableEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &attachmentCount, sizeof(attachmentCount)); + if (pColorWriteEnables) { + uint32_t n_ = (uint32_t)(attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pColorWriteEnables, (size_t)n_ * sizeof(*pColorWriteEnables)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetColorWriteMaskEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstAttachment, sizeof(firstAttachment)); + vkb_enc_bytes(e, &attachmentCount, sizeof(attachmentCount)); + if (pColorWriteMasks) { + uint32_t n_ = (uint32_t)(attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pColorWriteMasks, (size_t)n_ * sizeof(*pColorWriteMasks)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetConservativeRasterizationModeEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &conservativeRasterizationMode, sizeof(conservativeRasterizationMode)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetCoverageModulationModeNV); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &coverageModulationMode, sizeof(coverageModulationMode)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetCoverageModulationTableEnableNV); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &coverageModulationTableEnable, sizeof(coverageModulationTableEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetCoverageModulationTableNV); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &coverageModulationTableCount, sizeof(coverageModulationTableCount)); + if (pCoverageModulationTable) { + uint32_t n_ = (uint32_t)(coverageModulationTableCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pCoverageModulationTable, (size_t)n_ * sizeof(*pCoverageModulationTable)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetCoverageReductionModeNV); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &coverageReductionMode, sizeof(coverageReductionMode)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetCoverageToColorEnableNV); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &coverageToColorEnable, sizeof(coverageToColorEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetCoverageToColorLocationNV); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &coverageToColorLocation, sizeof(coverageToColorLocation)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetCullMode); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &cullMode, sizeof(cullMode)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthBias); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &depthBiasConstantFactor, sizeof(depthBiasConstantFactor)); + vkb_enc_bytes(e, &depthBiasClamp, sizeof(depthBiasClamp)); + vkb_enc_bytes(e, &depthBiasSlopeFactor, sizeof(depthBiasSlopeFactor)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthBiasEnable); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &depthBiasEnable, sizeof(depthBiasEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthBounds); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &minDepthBounds, sizeof(minDepthBounds)); + vkb_enc_bytes(e, &maxDepthBounds, sizeof(maxDepthBounds)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthBoundsTestEnable); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &depthBoundsTestEnable, sizeof(depthBoundsTestEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthClampEnableEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &depthClampEnable, sizeof(depthClampEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthClipEnableEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &depthClipEnable, sizeof(depthClipEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthClipNegativeOneToOneEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &negativeOneToOne, sizeof(negativeOneToOne)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthCompareOp); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &depthCompareOp, sizeof(depthCompareOp)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthTestEnable); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &depthTestEnable, sizeof(depthTestEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthWriteEnable); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &depthWriteEnable, sizeof(depthWriteEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDeviceMask); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &deviceMask, sizeof(deviceMask)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDiscardRectangleEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstDiscardRectangle, sizeof(firstDiscardRectangle)); + vkb_enc_bytes(e, &discardRectangleCount, sizeof(discardRectangleCount)); + if (pDiscardRectangles) { + uint32_t n_ = (uint32_t)(discardRectangleCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pDiscardRectangles, (size_t)n_ * sizeof(*pDiscardRectangles)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDiscardRectangleEnableEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &discardRectangleEnable, sizeof(discardRectangleEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDiscardRectangleModeEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &discardRectangleMode, sizeof(discardRectangleMode)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetEvent); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &event, sizeof(event)); + vkb_enc_bytes(e, &stageMask, sizeof(stageMask)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetEvent2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &event, sizeof(event)); + if (pDependencyInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDependencyInfo(e, &pDependencyInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetExtraPrimitiveOverestimationSizeEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &extraPrimitiveOverestimationSize, sizeof(extraPrimitiveOverestimationSize)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetFragmentShadingRateKHR); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pFragmentSize) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pFragmentSize, (size_t)n_ * sizeof(*pFragmentSize)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_raw(e, combinerOps, sizeof(VkFragmentShadingRateCombinerOpKHR) * 2); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetFrontFace); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &frontFace, sizeof(frontFace)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetLineRasterizationModeEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &lineRasterizationMode, sizeof(lineRasterizationMode)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetLineStippleEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &lineStippleFactor, sizeof(lineStippleFactor)); + vkb_enc_bytes(e, &lineStipplePattern, sizeof(lineStipplePattern)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetLineStippleEnableEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &stippledLineEnable, sizeof(stippledLineEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetLineWidth); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &lineWidth, sizeof(lineWidth)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetLogicOpEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &logicOp, sizeof(logicOp)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetLogicOpEnableEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &logicOpEnable, sizeof(logicOpEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetPatchControlPointsEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &patchControlPoints, sizeof(patchControlPoints)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetPolygonModeEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &polygonMode, sizeof(polygonMode)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetPrimitiveRestartEnable); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &primitiveRestartEnable, sizeof(primitiveRestartEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetPrimitiveTopology); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &primitiveTopology, sizeof(primitiveTopology)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetProvokingVertexModeEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &provokingVertexMode, sizeof(provokingVertexMode)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetRasterizationSamplesEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &rasterizationSamples, sizeof(rasterizationSamples)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetRasterizationStreamEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &rasterizationStream, sizeof(rasterizationStream)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetRasterizerDiscardEnable); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &rasterizerDiscardEnable, sizeof(rasterizerDiscardEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetRepresentativeFragmentTestEnableNV); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &representativeFragmentTestEnable, sizeof(representativeFragmentTestEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetSampleLocationsEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (pSampleLocationsInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSampleLocationsInfoEXT(e, &pSampleLocationsInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetSampleLocationsEnableEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &sampleLocationsEnable, sizeof(sampleLocationsEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetSampleMaskEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &samples, sizeof(samples)); + if (pSampleMask) { + uint32_t n_ = (uint32_t)((((uint32_t)samples + 31) / 32)); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pSampleMask, (size_t)n_ * sizeof(*pSampleMask)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetScissor); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstScissor, sizeof(firstScissor)); + vkb_enc_bytes(e, &scissorCount, sizeof(scissorCount)); + if (pScissors) { + uint32_t n_ = (uint32_t)(scissorCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pScissors, (size_t)n_ * sizeof(*pScissors)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetScissorWithCount); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &scissorCount, sizeof(scissorCount)); + if (pScissors) { + uint32_t n_ = (uint32_t)(scissorCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pScissors, (size_t)n_ * sizeof(*pScissors)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetShadingRateImageEnableNV); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &shadingRateImageEnable, sizeof(shadingRateImageEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetStencilCompareMask); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &faceMask, sizeof(faceMask)); + vkb_enc_bytes(e, &compareMask, sizeof(compareMask)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetStencilOp); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &faceMask, sizeof(faceMask)); + vkb_enc_bytes(e, &failOp, sizeof(failOp)); + vkb_enc_bytes(e, &passOp, sizeof(passOp)); + vkb_enc_bytes(e, &depthFailOp, sizeof(depthFailOp)); + vkb_enc_bytes(e, &compareOp, sizeof(compareOp)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetStencilReference); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &faceMask, sizeof(faceMask)); + vkb_enc_bytes(e, &reference, sizeof(reference)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetStencilTestEnable); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &stencilTestEnable, sizeof(stencilTestEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetStencilWriteMask); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &faceMask, sizeof(faceMask)); + vkb_enc_bytes(e, &writeMask, sizeof(writeMask)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetTessellationDomainOriginEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &domainOrigin, sizeof(domainOrigin)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetVertexInputEXT); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &vertexBindingDescriptionCount, sizeof(vertexBindingDescriptionCount)); + if (pVertexBindingDescriptions) { + uint32_t n_ = (uint32_t)(vertexBindingDescriptionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkVertexInputBindingDescription2EXT(e, &pVertexBindingDescriptions[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &vertexAttributeDescriptionCount, sizeof(vertexAttributeDescriptionCount)); + if (pVertexAttributeDescriptions) { + uint32_t n_ = (uint32_t)(vertexAttributeDescriptionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkVertexInputAttributeDescription2EXT(e, &pVertexAttributeDescriptions[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetViewport); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstViewport, sizeof(firstViewport)); + vkb_enc_bytes(e, &viewportCount, sizeof(viewportCount)); + if (pViewports) { + uint32_t n_ = (uint32_t)(viewportCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pViewports, (size_t)n_ * sizeof(*pViewports)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetViewportSwizzleNV); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &firstViewport, sizeof(firstViewport)); + vkb_enc_bytes(e, &viewportCount, sizeof(viewportCount)); + if (pViewportSwizzles) { + uint32_t n_ = (uint32_t)(viewportCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pViewportSwizzles, (size_t)n_ * sizeof(*pViewportSwizzles)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetViewportWScalingEnableNV); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &viewportWScalingEnable, sizeof(viewportWScalingEnable)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetViewportWithCount); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &viewportCount, sizeof(viewportCount)); + if (pViewports) { + uint32_t n_ = (uint32_t)(viewportCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pViewports, (size_t)n_ * sizeof(*pViewports)); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdUpdateBuffer); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &dstBuffer, sizeof(dstBuffer)); + vkb_enc_bytes(e, &dstOffset, sizeof(dstOffset)); + vkb_enc_bytes(e, &dataSize, sizeof(dataSize)); + vkb_enc_blob(e, pData ? (const void *)pData : NULL, pData ? (size_t)(dataSize) : 0); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdWaitEvents); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &eventCount, sizeof(eventCount)); + if (pEvents) { + uint32_t n_ = (uint32_t)(eventCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pEvents, (size_t)n_ * sizeof(*pEvents)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &srcStageMask, sizeof(srcStageMask)); + vkb_enc_bytes(e, &dstStageMask, sizeof(dstStageMask)); + vkb_enc_bytes(e, &memoryBarrierCount, sizeof(memoryBarrierCount)); + if (pMemoryBarriers) { + uint32_t n_ = (uint32_t)(memoryBarrierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkMemoryBarrier(e, &pMemoryBarriers[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &bufferMemoryBarrierCount, sizeof(bufferMemoryBarrierCount)); + if (pBufferMemoryBarriers) { + uint32_t n_ = (uint32_t)(bufferMemoryBarrierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferMemoryBarrier(e, &pBufferMemoryBarriers[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &imageMemoryBarrierCount, sizeof(imageMemoryBarrierCount)); + if (pImageMemoryBarriers) { + uint32_t n_ = (uint32_t)(imageMemoryBarrierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageMemoryBarrier(e, &pImageMemoryBarriers[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdWaitEvents2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &eventCount, sizeof(eventCount)); + if (pEvents) { + uint32_t n_ = (uint32_t)(eventCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pEvents, (size_t)n_ * sizeof(*pEvents)); + } else { + vkb_enc_u8(e, 0); + } + if (pDependencyInfos) { + uint32_t n_ = (uint32_t)(eventCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDependencyInfo(e, &pDependencyInfos[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdWriteTimestamp); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &pipelineStage, sizeof(pipelineStage)); + vkb_enc_bytes(e, &queryPool, sizeof(queryPool)); + vkb_enc_bytes(e, &query, sizeof(query)); + vkb_cmd_record_end(commandBuffer); +} + +void vkb_wire_vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdWriteTimestamp2); + if (!e) return; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &stage, sizeof(stage)); + vkb_enc_bytes(e, &queryPool, sizeof(queryPool)); + vkb_enc_bytes(e, &query, sizeof(query)); + vkb_cmd_record_end(commandBuffer); +} + +VkResult vkb_wire_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateBuffer, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pBuffer != NULL); + if (pBuffer) vkb_enc_bytes(e, pBuffer, sizeof(*pBuffer)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pBuffer) vkb_dec_raw_into(d, pBuffer, sizeof(*pBuffer)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateBufferView, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferViewCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pView != NULL); + if (pView) vkb_enc_bytes(e, pView, sizeof(*pView)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pView) vkb_dec_raw_into(d, pView, sizeof(*pView)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateCommandPool, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkCommandPoolCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pCommandPool != NULL); + if (pCommandPool) vkb_enc_bytes(e, pCommandPool, sizeof(*pCommandPool)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pCommandPool) vkb_dec_raw_into(d, pCommandPool, sizeof(*pCommandPool)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateComputePipelines, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &pipelineCache, sizeof(pipelineCache)); + vkb_enc_bytes(e, &createInfoCount, sizeof(createInfoCount)); + if (pCreateInfos) { + uint32_t n_ = (uint32_t)(createInfoCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkComputePipelineCreateInfo(e, &pCreateInfos[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + { uint32_t n_ = pPipelines ? (uint32_t)(createInfoCount) : 0; + vkb_enc_u8(e, pPipelines != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = pPipelines ? (uint32_t)(createInfoCount) : 0; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_raw_into(d, &pPipelines[i_], sizeof(VkPipeline)); + } + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateDescriptorPool, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDescriptorPoolCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pDescriptorPool != NULL); + if (pDescriptorPool) vkb_enc_bytes(e, pDescriptorPool, sizeof(*pDescriptorPool)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pDescriptorPool) vkb_dec_raw_into(d, pDescriptorPool, sizeof(*pDescriptorPool)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateDescriptorSetLayout, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDescriptorSetLayoutCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pSetLayout != NULL); + if (pSetLayout) vkb_enc_bytes(e, pSetLayout, sizeof(*pSetLayout)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pSetLayout) vkb_dec_raw_into(d, pSetLayout, sizeof(*pSetLayout)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateDescriptorUpdateTemplate, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDescriptorUpdateTemplateCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pDescriptorUpdateTemplate != NULL); + if (pDescriptorUpdateTemplate) vkb_enc_bytes(e, pDescriptorUpdateTemplate, sizeof(*pDescriptorUpdateTemplate)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pDescriptorUpdateTemplate) vkb_dec_raw_into(d, pDescriptorUpdateTemplate, sizeof(*pDescriptorUpdateTemplate)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateDevice, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDeviceCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pDevice != NULL); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + VkDevice h_ = (VkDevice)vkb_wrap(VK_OBJECT_TYPE_DEVICE, (const void *)physicalDevice, vkb_dec_u64(d)); + if (pDevice) *pDevice = h_; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateEvent, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkEventCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pEvent != NULL); + if (pEvent) vkb_enc_bytes(e, pEvent, sizeof(*pEvent)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pEvent) vkb_dec_raw_into(d, pEvent, sizeof(*pEvent)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateFence, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkFenceCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pFence != NULL); + if (pFence) vkb_enc_bytes(e, pFence, sizeof(*pFence)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pFence) vkb_dec_raw_into(d, pFence, sizeof(*pFence)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateFramebuffer, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkFramebufferCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pFramebuffer != NULL); + if (pFramebuffer) vkb_enc_bytes(e, pFramebuffer, sizeof(*pFramebuffer)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pFramebuffer) vkb_dec_raw_into(d, pFramebuffer, sizeof(*pFramebuffer)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateGraphicsPipelines, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &pipelineCache, sizeof(pipelineCache)); + vkb_enc_bytes(e, &createInfoCount, sizeof(createInfoCount)); + if (pCreateInfos) { + uint32_t n_ = (uint32_t)(createInfoCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkGraphicsPipelineCreateInfo(e, &pCreateInfos[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + { uint32_t n_ = pPipelines ? (uint32_t)(createInfoCount) : 0; + vkb_enc_u8(e, pPipelines != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = pPipelines ? (uint32_t)(createInfoCount) : 0; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_raw_into(d, &pPipelines[i_], sizeof(VkPipeline)); + } + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateImage, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pImage != NULL); + if (pImage) vkb_enc_bytes(e, pImage, sizeof(*pImage)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pImage) vkb_dec_raw_into(d, pImage, sizeof(*pImage)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateImageView, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageViewCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pView != NULL); + if (pView) vkb_enc_bytes(e, pView, sizeof(*pView)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pView) vkb_dec_raw_into(d, pView, sizeof(*pView)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateInstance, 0); + vkb_enc *e = &call_.e; + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkInstanceCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pInstance != NULL); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + VkInstance h_ = (VkInstance)vkb_wrap(VK_OBJECT_TYPE_INSTANCE, (const void *)NULL, vkb_dec_u64(d)); + if (pInstance) *pInstance = h_; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreatePipelineCache, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineCacheCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pPipelineCache != NULL); + if (pPipelineCache) vkb_enc_bytes(e, pPipelineCache, sizeof(*pPipelineCache)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pPipelineCache) vkb_dec_raw_into(d, pPipelineCache, sizeof(*pPipelineCache)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreatePipelineLayout, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineLayoutCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pPipelineLayout != NULL); + if (pPipelineLayout) vkb_enc_bytes(e, pPipelineLayout, sizeof(*pPipelineLayout)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pPipelineLayout) vkb_dec_raw_into(d, pPipelineLayout, sizeof(*pPipelineLayout)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateQueryPool, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkQueryPoolCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pQueryPool != NULL); + if (pQueryPool) vkb_enc_bytes(e, pQueryPool, sizeof(*pQueryPool)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pQueryPool) vkb_dec_raw_into(d, pQueryPool, sizeof(*pQueryPool)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateRenderPass, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkRenderPassCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pRenderPass != NULL); + if (pRenderPass) vkb_enc_bytes(e, pRenderPass, sizeof(*pRenderPass)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pRenderPass) vkb_dec_raw_into(d, pRenderPass, sizeof(*pRenderPass)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateRenderPass2, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkRenderPassCreateInfo2(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pRenderPass != NULL); + if (pRenderPass) vkb_enc_bytes(e, pRenderPass, sizeof(*pRenderPass)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pRenderPass) vkb_dec_raw_into(d, pRenderPass, sizeof(*pRenderPass)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateSampler, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSamplerCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pSampler != NULL); + if (pSampler) vkb_enc_bytes(e, pSampler, sizeof(*pSampler)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pSampler) vkb_dec_raw_into(d, pSampler, sizeof(*pSampler)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateSamplerYcbcrConversion, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSamplerYcbcrConversionCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pYcbcrConversion != NULL); + if (pYcbcrConversion) vkb_enc_bytes(e, pYcbcrConversion, sizeof(*pYcbcrConversion)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pYcbcrConversion) vkb_dec_raw_into(d, pYcbcrConversion, sizeof(*pYcbcrConversion)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateSemaphore, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSemaphoreCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pSemaphore != NULL); + if (pSemaphore) vkb_enc_bytes(e, pSemaphore, sizeof(*pSemaphore)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pSemaphore) vkb_dec_raw_into(d, pSemaphore, sizeof(*pSemaphore)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkCreateShaderModule, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkShaderModuleCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + (void)pAllocator; + vkb_enc_u8(e, pShaderModule != NULL); + if (pShaderModule) vkb_enc_bytes(e, pShaderModule, sizeof(*pShaderModule)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pShaderModule) vkb_dec_raw_into(d, pShaderModule, sizeof(*pShaderModule)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyBuffer, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &buffer, sizeof(buffer)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyBufferView, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &bufferView, sizeof(bufferView)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyCommandPool, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &commandPool, sizeof(commandPool)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyDescriptorPool, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &descriptorPool, sizeof(descriptorPool)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyDescriptorSetLayout, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &descriptorSetLayout, sizeof(descriptorSetLayout)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyDescriptorUpdateTemplate, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &descriptorUpdateTemplate, sizeof(descriptorUpdateTemplate)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyDevice, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyEvent, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &event, sizeof(event)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyFence, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &fence, sizeof(fence)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyFramebuffer, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &framebuffer, sizeof(framebuffer)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyImage, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &image, sizeof(image)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyImageView, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &imageView, sizeof(imageView)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyInstance, vkb_table_of((const void *)instance)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)instance)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyPipeline, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &pipeline, sizeof(pipeline)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyPipelineCache, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &pipelineCache, sizeof(pipelineCache)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyPipelineLayout, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &pipelineLayout, sizeof(pipelineLayout)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyQueryPool, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &queryPool, sizeof(queryPool)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyRenderPass, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &renderPass, sizeof(renderPass)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroySampler, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &sampler, sizeof(sampler)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroySamplerYcbcrConversion, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &ycbcrConversion, sizeof(ycbcrConversion)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroySemaphore, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &semaphore, sizeof(semaphore)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDestroyShaderModule, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &shaderModule, sizeof(shaderModule)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +VkResult vkb_wire_vkDeviceWaitIdle(VkDevice device) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkDeviceWaitIdle, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkEndCommandBuffer(VkCommandBuffer commandBuffer) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkEndCommandBuffer, vkb_table_of((const void *)commandBuffer)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkEnumerateDeviceExtensionProperties, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_str(e, pLayerName ? pLayerName : NULL); + vkb_enc_u8(e, pPropertyCount != NULL); + if (pPropertyCount) vkb_enc_bytes(e, pPropertyCount, sizeof(*pPropertyCount)); + { uint32_t n_ = pProperties ? (uint32_t)((pPropertyCount ? *pPropertyCount : 0)) : 0; + vkb_enc_u8(e, pProperties != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pPropertyCount) vkb_dec_raw_into(d, pPropertyCount, sizeof(*pPropertyCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pProperties && pPropertyCount) ? *pPropertyCount : 0; + if (pPropertyCount) *pPropertyCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_raw_into(d, &pProperties[i_], sizeof(VkExtensionProperties)); + } + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkEnumerateInstanceExtensionProperties, 0); + vkb_enc *e = &call_.e; + vkb_enc_str(e, pLayerName ? pLayerName : NULL); + vkb_enc_u8(e, pPropertyCount != NULL); + if (pPropertyCount) vkb_enc_bytes(e, pPropertyCount, sizeof(*pPropertyCount)); + { uint32_t n_ = pProperties ? (uint32_t)((pPropertyCount ? *pPropertyCount : 0)) : 0; + vkb_enc_u8(e, pProperties != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pPropertyCount) vkb_dec_raw_into(d, pPropertyCount, sizeof(*pPropertyCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pProperties && pPropertyCount) ? *pPropertyCount : 0; + if (pPropertyCount) *pPropertyCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_raw_into(d, &pProperties[i_], sizeof(VkExtensionProperties)); + } + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkEnumerateInstanceLayerProperties, 0); + vkb_enc *e = &call_.e; + vkb_enc_u8(e, pPropertyCount != NULL); + if (pPropertyCount) vkb_enc_bytes(e, pPropertyCount, sizeof(*pPropertyCount)); + { uint32_t n_ = pProperties ? (uint32_t)((pPropertyCount ? *pPropertyCount : 0)) : 0; + vkb_enc_u8(e, pProperties != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pPropertyCount) vkb_dec_raw_into(d, pPropertyCount, sizeof(*pPropertyCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pProperties && pPropertyCount) ? *pPropertyCount : 0; + if (pPropertyCount) *pPropertyCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_raw_into(d, &pProperties[i_], sizeof(VkLayerProperties)); + } + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkEnumerateInstanceVersion(uint32_t* pApiVersion) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkEnumerateInstanceVersion, 0); + vkb_enc *e = &call_.e; + vkb_enc_u8(e, pApiVersion != NULL); + if (pApiVersion) vkb_enc_bytes(e, pApiVersion, sizeof(*pApiVersion)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pApiVersion) vkb_dec_raw_into(d, pApiVersion, sizeof(*pApiVersion)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkEnumeratePhysicalDeviceGroups, vkb_table_of((const void *)instance)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)instance)); + vkb_enc_u8(e, pPhysicalDeviceGroupCount != NULL); + if (pPhysicalDeviceGroupCount) vkb_enc_bytes(e, pPhysicalDeviceGroupCount, sizeof(*pPhysicalDeviceGroupCount)); + { uint32_t n_ = pPhysicalDeviceGroupProperties ? (uint32_t)((pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0)) : 0; + vkb_enc_u8(e, pPhysicalDeviceGroupProperties != NULL); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; pPhysicalDeviceGroupProperties && i_ < n_; i_++) vkb_enc_out_template(e, &pPhysicalDeviceGroupProperties[i_], sizeof(VkPhysicalDeviceGroupProperties)); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pPhysicalDeviceGroupCount) vkb_dec_raw_into(d, pPhysicalDeviceGroupCount, sizeof(*pPhysicalDeviceGroupCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pPhysicalDeviceGroupProperties && pPhysicalDeviceGroupCount) ? *pPhysicalDeviceGroupCount : 0; + if (pPhysicalDeviceGroupCount) *pPhysicalDeviceGroupCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_out_struct(d, &pPhysicalDeviceGroupProperties[i_], sizeof(VkPhysicalDeviceGroupProperties)); + } + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkEnumeratePhysicalDevices, vkb_table_of((const void *)instance)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)instance)); + vkb_enc_u8(e, pPhysicalDeviceCount != NULL); + if (pPhysicalDeviceCount) vkb_enc_bytes(e, pPhysicalDeviceCount, sizeof(*pPhysicalDeviceCount)); + { uint32_t n_ = pPhysicalDevices ? (uint32_t)((pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0)) : 0; + vkb_enc_u8(e, pPhysicalDevices != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pPhysicalDeviceCount) vkb_dec_raw_into(d, pPhysicalDeviceCount, sizeof(*pPhysicalDeviceCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pPhysicalDevices && pPhysicalDeviceCount) ? *pPhysicalDeviceCount : 0; + if (pPhysicalDeviceCount) *pPhysicalDeviceCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + pPhysicalDevices[i_] = (VkPhysicalDevice)vkb_wrap(VK_OBJECT_TYPE_PHYSICAL_DEVICE, (const void *)instance, vkb_dec_u64(d)); + } + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkFlushMappedMemoryRanges, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &memoryRangeCount, sizeof(memoryRangeCount)); + if (pMemoryRanges) { + uint32_t n_ = (uint32_t)(memoryRangeCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkMappedMemoryRange(e, &pMemoryRanges[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkFreeCommandBuffers, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &commandPool, sizeof(commandPool)); + vkb_enc_bytes(e, &commandBufferCount, sizeof(commandBufferCount)); + if (pCommandBuffers) { + uint32_t n_ = (uint32_t)(commandBufferCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_u64(e, vkb_remote((const void *)pCommandBuffers[i_])); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +VkResult vkb_wire_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkFreeDescriptorSets, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &descriptorPool, sizeof(descriptorPool)); + vkb_enc_bytes(e, &descriptorSetCount, sizeof(descriptorSetCount)); + if (pDescriptorSets) { + uint32_t n_ = (uint32_t)(descriptorSetCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pDescriptorSets, (size_t)n_ * sizeof(*pDescriptorSets)); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkFreeMemory, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &memory, sizeof(memory)); + (void)pAllocator; + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +VkDeviceAddress vkb_wire_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetBufferDeviceAddress, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferDeviceAddressInfo(e, &pInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return (VkDeviceAddress)0; + } + vkb_dec *d = &call_.d; + (void)d; + VkDeviceAddress r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetBufferMemoryRequirements, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &buffer, sizeof(buffer)); + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pMemoryRequirements) vkb_dec_raw_into(d, pMemoryRequirements, sizeof(*pMemoryRequirements)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetBufferMemoryRequirements2, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferMemoryRequirementsInfo2(e, &pInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (pMemoryRequirements) vkb_enc_out_template(e, pMemoryRequirements, sizeof(VkMemoryRequirements2)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pMemoryRequirements) vkb_dec_out_struct(d, pMemoryRequirements, sizeof(VkMemoryRequirements2)); else d->err = 1; + } + vkb_call_end(&call_); +} + +uint64_t vkb_wire_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetBufferOpaqueCaptureAddress, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferDeviceAddressInfo(e, &pInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return (uint64_t)0; + } + vkb_dec *d = &call_.d; + (void)d; + uint64_t r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetCalibratedTimestampsEXT, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, ×tampCount, sizeof(timestampCount)); + if (pTimestampInfos) { + uint32_t n_ = (uint32_t)(timestampCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkCalibratedTimestampInfoEXT(e, &pTimestampInfos[i_]); + } else { + vkb_enc_u8(e, 0); + } + { uint32_t n_ = pTimestamps ? (uint32_t)(timestampCount) : 0; + vkb_enc_u8(e, pTimestamps != NULL); vkb_enc_u32(e, n_); + } + vkb_enc_u8(e, pMaxDeviation != NULL); + if (pMaxDeviation) vkb_enc_bytes(e, pMaxDeviation, sizeof(*pMaxDeviation)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = pTimestamps ? (uint32_t)(timestampCount) : 0; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_raw_into(d, &pTimestamps[i_], sizeof(uint64_t)); + } + } + if (vkb_dec_u8(d)) { + if (pMaxDeviation) vkb_dec_raw_into(d, pMaxDeviation, sizeof(*pMaxDeviation)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetDescriptorSetLayoutSupport, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDescriptorSetLayoutCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pSupport != NULL); + if (pSupport) vkb_enc_out_template(e, pSupport, sizeof(VkDescriptorSetLayoutSupport)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pSupport) vkb_dec_out_struct(d, pSupport, sizeof(VkDescriptorSetLayoutSupport)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetDeviceBufferMemoryRequirements, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDeviceBufferMemoryRequirements(e, &pInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (pMemoryRequirements) vkb_enc_out_template(e, pMemoryRequirements, sizeof(VkMemoryRequirements2)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pMemoryRequirements) vkb_dec_out_struct(d, pMemoryRequirements, sizeof(VkMemoryRequirements2)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetDeviceGroupPeerMemoryFeatures, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &heapIndex, sizeof(heapIndex)); + vkb_enc_bytes(e, &localDeviceIndex, sizeof(localDeviceIndex)); + vkb_enc_bytes(e, &remoteDeviceIndex, sizeof(remoteDeviceIndex)); + vkb_enc_u8(e, pPeerMemoryFeatures != NULL); + if (pPeerMemoryFeatures) vkb_enc_bytes(e, pPeerMemoryFeatures, sizeof(*pPeerMemoryFeatures)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pPeerMemoryFeatures) vkb_dec_raw_into(d, pPeerMemoryFeatures, sizeof(*pPeerMemoryFeatures)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetDeviceImageMemoryRequirements, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDeviceImageMemoryRequirements(e, &pInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (pMemoryRequirements) vkb_enc_out_template(e, pMemoryRequirements, sizeof(VkMemoryRequirements2)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pMemoryRequirements) vkb_dec_out_struct(d, pMemoryRequirements, sizeof(VkMemoryRequirements2)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetDeviceImageSparseMemoryRequirements, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDeviceImageMemoryRequirements(e, &pInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pSparseMemoryRequirementCount != NULL); + if (pSparseMemoryRequirementCount) vkb_enc_bytes(e, pSparseMemoryRequirementCount, sizeof(*pSparseMemoryRequirementCount)); + { uint32_t n_ = pSparseMemoryRequirements ? (uint32_t)((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)) : 0; + vkb_enc_u8(e, pSparseMemoryRequirements != NULL); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; pSparseMemoryRequirements && i_ < n_; i_++) vkb_enc_out_template(e, &pSparseMemoryRequirements[i_], sizeof(VkSparseImageMemoryRequirements2)); + } + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pSparseMemoryRequirementCount) vkb_dec_raw_into(d, pSparseMemoryRequirementCount, sizeof(*pSparseMemoryRequirementCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pSparseMemoryRequirements && pSparseMemoryRequirementCount) ? *pSparseMemoryRequirementCount : 0; + if (pSparseMemoryRequirementCount) *pSparseMemoryRequirementCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_out_struct(d, &pSparseMemoryRequirements[i_], sizeof(VkSparseImageMemoryRequirements2)); + } + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetDeviceMemoryCommitment, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &memory, sizeof(memory)); + vkb_enc_u8(e, pCommittedMemoryInBytes != NULL); + if (pCommittedMemoryInBytes) vkb_enc_bytes(e, pCommittedMemoryInBytes, sizeof(*pCommittedMemoryInBytes)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pCommittedMemoryInBytes) vkb_dec_raw_into(d, pCommittedMemoryInBytes, sizeof(*pCommittedMemoryInBytes)); else d->err = 1; + } + vkb_call_end(&call_); +} + +uint64_t vkb_wire_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetDeviceMemoryOpaqueCaptureAddress, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDeviceMemoryOpaqueCaptureAddressInfo(e, &pInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return (uint64_t)0; + } + vkb_dec *d = &call_.d; + (void)d; + uint64_t r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetDeviceQueue, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &queueFamilyIndex, sizeof(queueFamilyIndex)); + vkb_enc_bytes(e, &queueIndex, sizeof(queueIndex)); + vkb_enc_u8(e, pQueue != NULL); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + VkQueue h_ = (VkQueue)vkb_wrap(VK_OBJECT_TYPE_QUEUE, (const void *)device, vkb_dec_u64(d)); + if (pQueue) *pQueue = h_; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetDeviceQueue2, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pQueueInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDeviceQueueInfo2(e, &pQueueInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pQueue != NULL); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + VkQueue h_ = (VkQueue)vkb_wrap(VK_OBJECT_TYPE_QUEUE, (const void *)device, vkb_dec_u64(d)); + if (pQueue) *pQueue = h_; + } + vkb_call_end(&call_); +} + +VkResult vkb_wire_vkGetEventStatus(VkDevice device, VkEvent event) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetEventStatus, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &event, sizeof(event)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetFenceFdKHR, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pGetFdInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkFenceGetFdInfoKHR(e, &pGetFdInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pFd != NULL); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + { int fd_ = vkb_dec_fd(d); if (pFd) *pFd = fd_; else if (fd_ >= 0) vkb_close_fd(fd_); } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkGetFenceStatus(VkDevice device, VkFence fence) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetFenceStatus, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &fence, sizeof(fence)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetImageDrmFormatModifierPropertiesEXT, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &image, sizeof(image)); + vkb_enc_u8(e, pProperties != NULL); + if (pProperties) vkb_enc_out_template(e, pProperties, sizeof(VkImageDrmFormatModifierPropertiesEXT)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pProperties) vkb_dec_out_struct(d, pProperties, sizeof(VkImageDrmFormatModifierPropertiesEXT)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetImageMemoryRequirements, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &image, sizeof(image)); + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pMemoryRequirements) vkb_dec_raw_into(d, pMemoryRequirements, sizeof(*pMemoryRequirements)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetImageMemoryRequirements2, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageMemoryRequirementsInfo2(e, &pInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (pMemoryRequirements) vkb_enc_out_template(e, pMemoryRequirements, sizeof(VkMemoryRequirements2)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pMemoryRequirements) vkb_dec_out_struct(d, pMemoryRequirements, sizeof(VkMemoryRequirements2)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetImageSparseMemoryRequirements, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &image, sizeof(image)); + vkb_enc_u8(e, pSparseMemoryRequirementCount != NULL); + if (pSparseMemoryRequirementCount) vkb_enc_bytes(e, pSparseMemoryRequirementCount, sizeof(*pSparseMemoryRequirementCount)); + { uint32_t n_ = pSparseMemoryRequirements ? (uint32_t)((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)) : 0; + vkb_enc_u8(e, pSparseMemoryRequirements != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pSparseMemoryRequirementCount) vkb_dec_raw_into(d, pSparseMemoryRequirementCount, sizeof(*pSparseMemoryRequirementCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pSparseMemoryRequirements && pSparseMemoryRequirementCount) ? *pSparseMemoryRequirementCount : 0; + if (pSparseMemoryRequirementCount) *pSparseMemoryRequirementCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_raw_into(d, &pSparseMemoryRequirements[i_], sizeof(VkSparseImageMemoryRequirements)); + } + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetImageSparseMemoryRequirements2, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageSparseMemoryRequirementsInfo2(e, &pInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pSparseMemoryRequirementCount != NULL); + if (pSparseMemoryRequirementCount) vkb_enc_bytes(e, pSparseMemoryRequirementCount, sizeof(*pSparseMemoryRequirementCount)); + { uint32_t n_ = pSparseMemoryRequirements ? (uint32_t)((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0)) : 0; + vkb_enc_u8(e, pSparseMemoryRequirements != NULL); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; pSparseMemoryRequirements && i_ < n_; i_++) vkb_enc_out_template(e, &pSparseMemoryRequirements[i_], sizeof(VkSparseImageMemoryRequirements2)); + } + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pSparseMemoryRequirementCount) vkb_dec_raw_into(d, pSparseMemoryRequirementCount, sizeof(*pSparseMemoryRequirementCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pSparseMemoryRequirements && pSparseMemoryRequirementCount) ? *pSparseMemoryRequirementCount : 0; + if (pSparseMemoryRequirementCount) *pSparseMemoryRequirementCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_out_struct(d, &pSparseMemoryRequirements[i_], sizeof(VkSparseImageMemoryRequirements2)); + } + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetImageSubresourceLayout, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &image, sizeof(image)); + if (pSubresource) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pSubresource, (size_t)n_ * sizeof(*pSubresource)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pLayout != NULL); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pLayout) vkb_dec_raw_into(d, pLayout, sizeof(*pLayout)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetImageSubresourceLayout2EXT, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &image, sizeof(image)); + if (pSubresource) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageSubresource2EXT(e, &pSubresource[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pLayout != NULL); + if (pLayout) vkb_enc_out_template(e, pLayout, sizeof(VkSubresourceLayout2EXT)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pLayout) vkb_dec_out_struct(d, pLayout, sizeof(VkSubresourceLayout2EXT)); else d->err = 1; + } + vkb_call_end(&call_); +} + +VkResult vkb_wire_vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetMemoryFdKHR, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pGetFdInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkMemoryGetFdInfoKHR(e, &pGetFdInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pFd != NULL); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + { int fd_ = vkb_dec_fd(d); if (pFd) *pFd = fd_; else if (fd_ >= 0) vkb_close_fd(fd_); } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetMemoryFdPropertiesKHR, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &handleType, sizeof(handleType)); + vkb_enc_fd(e, fd); + vkb_enc_u8(e, pMemoryFdProperties != NULL); + if (pMemoryFdProperties) vkb_enc_out_template(e, pMemoryFdProperties, sizeof(VkMemoryFdPropertiesKHR)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pMemoryFdProperties) vkb_dec_out_struct(d, pMemoryFdProperties, sizeof(VkMemoryFdPropertiesKHR)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_u8(e, pTimeDomainCount != NULL); + if (pTimeDomainCount) vkb_enc_bytes(e, pTimeDomainCount, sizeof(*pTimeDomainCount)); + { uint32_t n_ = pTimeDomains ? (uint32_t)((pTimeDomainCount ? *pTimeDomainCount : 0)) : 0; + vkb_enc_u8(e, pTimeDomains != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pTimeDomainCount) vkb_dec_raw_into(d, pTimeDomainCount, sizeof(*pTimeDomainCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pTimeDomains && pTimeDomainCount) ? *pTimeDomainCount : 0; + if (pTimeDomainCount) *pTimeDomainCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_raw_into(d, &pTimeDomains[i_], sizeof(VkTimeDomainEXT)); + } + } + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceExternalBufferProperties, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + if (pExternalBufferInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPhysicalDeviceExternalBufferInfo(e, &pExternalBufferInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pExternalBufferProperties != NULL); + if (pExternalBufferProperties) vkb_enc_out_template(e, pExternalBufferProperties, sizeof(VkExternalBufferProperties)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pExternalBufferProperties) vkb_dec_out_struct(d, pExternalBufferProperties, sizeof(VkExternalBufferProperties)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceExternalFenceProperties, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + if (pExternalFenceInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPhysicalDeviceExternalFenceInfo(e, &pExternalFenceInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pExternalFenceProperties != NULL); + if (pExternalFenceProperties) vkb_enc_out_template(e, pExternalFenceProperties, sizeof(VkExternalFenceProperties)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pExternalFenceProperties) vkb_dec_out_struct(d, pExternalFenceProperties, sizeof(VkExternalFenceProperties)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceExternalSemaphoreProperties, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + if (pExternalSemaphoreInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPhysicalDeviceExternalSemaphoreInfo(e, &pExternalSemaphoreInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pExternalSemaphoreProperties != NULL); + if (pExternalSemaphoreProperties) vkb_enc_out_template(e, pExternalSemaphoreProperties, sizeof(VkExternalSemaphoreProperties)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pExternalSemaphoreProperties) vkb_dec_out_struct(d, pExternalSemaphoreProperties, sizeof(VkExternalSemaphoreProperties)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceFeatures, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_u8(e, pFeatures != NULL); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pFeatures) vkb_dec_raw_into(d, pFeatures, sizeof(*pFeatures)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceFeatures2, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_u8(e, pFeatures != NULL); + if (pFeatures) vkb_enc_out_template(e, pFeatures, sizeof(VkPhysicalDeviceFeatures2)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pFeatures) vkb_dec_out_struct(d, pFeatures, sizeof(VkPhysicalDeviceFeatures2)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceFormatProperties, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_bytes(e, &format, sizeof(format)); + vkb_enc_u8(e, pFormatProperties != NULL); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pFormatProperties) vkb_dec_raw_into(d, pFormatProperties, sizeof(*pFormatProperties)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceFormatProperties2, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_bytes(e, &format, sizeof(format)); + vkb_enc_u8(e, pFormatProperties != NULL); + if (pFormatProperties) vkb_enc_out_template(e, pFormatProperties, sizeof(VkFormatProperties2)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pFormatProperties) vkb_dec_out_struct(d, pFormatProperties, sizeof(VkFormatProperties2)); else d->err = 1; + } + vkb_call_end(&call_); +} + +VkResult vkb_wire_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceFragmentShadingRatesKHR, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_u8(e, pFragmentShadingRateCount != NULL); + if (pFragmentShadingRateCount) vkb_enc_bytes(e, pFragmentShadingRateCount, sizeof(*pFragmentShadingRateCount)); + { uint32_t n_ = pFragmentShadingRates ? (uint32_t)((pFragmentShadingRateCount ? *pFragmentShadingRateCount : 0)) : 0; + vkb_enc_u8(e, pFragmentShadingRates != NULL); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; pFragmentShadingRates && i_ < n_; i_++) vkb_enc_out_template(e, &pFragmentShadingRates[i_], sizeof(VkPhysicalDeviceFragmentShadingRateKHR)); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pFragmentShadingRateCount) vkb_dec_raw_into(d, pFragmentShadingRateCount, sizeof(*pFragmentShadingRateCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pFragmentShadingRates && pFragmentShadingRateCount) ? *pFragmentShadingRateCount : 0; + if (pFragmentShadingRateCount) *pFragmentShadingRateCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_out_struct(d, &pFragmentShadingRates[i_], sizeof(VkPhysicalDeviceFragmentShadingRateKHR)); + } + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceImageFormatProperties, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_bytes(e, &format, sizeof(format)); + vkb_enc_bytes(e, &type, sizeof(type)); + vkb_enc_bytes(e, &tiling, sizeof(tiling)); + vkb_enc_bytes(e, &usage, sizeof(usage)); + vkb_enc_bytes(e, &flags, sizeof(flags)); + vkb_enc_u8(e, pImageFormatProperties != NULL); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pImageFormatProperties) vkb_dec_raw_into(d, pImageFormatProperties, sizeof(*pImageFormatProperties)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceImageFormatProperties2, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + if (pImageFormatInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPhysicalDeviceImageFormatInfo2(e, &pImageFormatInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pImageFormatProperties != NULL); + if (pImageFormatProperties) vkb_enc_out_template(e, pImageFormatProperties, sizeof(VkImageFormatProperties2)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pImageFormatProperties) vkb_dec_out_struct(d, pImageFormatProperties, sizeof(VkImageFormatProperties2)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceMemoryProperties, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_u8(e, pMemoryProperties != NULL); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pMemoryProperties) vkb_dec_raw_into(d, pMemoryProperties, sizeof(*pMemoryProperties)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceMemoryProperties2, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_u8(e, pMemoryProperties != NULL); + if (pMemoryProperties) vkb_enc_out_template(e, pMemoryProperties, sizeof(VkPhysicalDeviceMemoryProperties2)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pMemoryProperties) vkb_dec_out_struct(d, pMemoryProperties, sizeof(VkPhysicalDeviceMemoryProperties2)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceMultisamplePropertiesEXT, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_bytes(e, &samples, sizeof(samples)); + vkb_enc_u8(e, pMultisampleProperties != NULL); + if (pMultisampleProperties) vkb_enc_out_template(e, pMultisampleProperties, sizeof(VkMultisamplePropertiesEXT)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pMultisampleProperties) vkb_dec_out_struct(d, pMultisampleProperties, sizeof(VkMultisamplePropertiesEXT)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceProperties, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_u8(e, pProperties != NULL); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pProperties) vkb_dec_raw_into(d, pProperties, sizeof(*pProperties)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceProperties2, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_u8(e, pProperties != NULL); + if (pProperties) vkb_enc_out_template(e, pProperties, sizeof(VkPhysicalDeviceProperties2)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pProperties) vkb_dec_out_struct(d, pProperties, sizeof(VkPhysicalDeviceProperties2)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_u8(e, pQueueFamilyPropertyCount != NULL); + if (pQueueFamilyPropertyCount) vkb_enc_bytes(e, pQueueFamilyPropertyCount, sizeof(*pQueueFamilyPropertyCount)); + { uint32_t n_ = pQueueFamilyProperties ? (uint32_t)((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0)) : 0; + vkb_enc_u8(e, pQueueFamilyProperties != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pQueueFamilyPropertyCount) vkb_dec_raw_into(d, pQueueFamilyPropertyCount, sizeof(*pQueueFamilyPropertyCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pQueueFamilyProperties && pQueueFamilyPropertyCount) ? *pQueueFamilyPropertyCount : 0; + if (pQueueFamilyPropertyCount) *pQueueFamilyPropertyCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_raw_into(d, &pQueueFamilyProperties[i_], sizeof(VkQueueFamilyProperties)); + } + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties2, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_u8(e, pQueueFamilyPropertyCount != NULL); + if (pQueueFamilyPropertyCount) vkb_enc_bytes(e, pQueueFamilyPropertyCount, sizeof(*pQueueFamilyPropertyCount)); + { uint32_t n_ = pQueueFamilyProperties ? (uint32_t)((pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0)) : 0; + vkb_enc_u8(e, pQueueFamilyProperties != NULL); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; pQueueFamilyProperties && i_ < n_; i_++) vkb_enc_out_template(e, &pQueueFamilyProperties[i_], sizeof(VkQueueFamilyProperties2)); + } + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pQueueFamilyPropertyCount) vkb_dec_raw_into(d, pQueueFamilyPropertyCount, sizeof(*pQueueFamilyPropertyCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pQueueFamilyProperties && pQueueFamilyPropertyCount) ? *pQueueFamilyPropertyCount : 0; + if (pQueueFamilyPropertyCount) *pQueueFamilyPropertyCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_out_struct(d, &pQueueFamilyProperties[i_], sizeof(VkQueueFamilyProperties2)); + } + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_bytes(e, &format, sizeof(format)); + vkb_enc_bytes(e, &type, sizeof(type)); + vkb_enc_bytes(e, &samples, sizeof(samples)); + vkb_enc_bytes(e, &usage, sizeof(usage)); + vkb_enc_bytes(e, &tiling, sizeof(tiling)); + vkb_enc_u8(e, pPropertyCount != NULL); + if (pPropertyCount) vkb_enc_bytes(e, pPropertyCount, sizeof(*pPropertyCount)); + { uint32_t n_ = pProperties ? (uint32_t)((pPropertyCount ? *pPropertyCount : 0)) : 0; + vkb_enc_u8(e, pProperties != NULL); vkb_enc_u32(e, n_); + } + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pPropertyCount) vkb_dec_raw_into(d, pPropertyCount, sizeof(*pPropertyCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pProperties && pPropertyCount) ? *pPropertyCount : 0; + if (pPropertyCount) *pPropertyCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_raw_into(d, &pProperties[i_], sizeof(VkSparseImageFormatProperties)); + } + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties2, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + if (pFormatInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPhysicalDeviceSparseImageFormatInfo2(e, &pFormatInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pPropertyCount != NULL); + if (pPropertyCount) vkb_enc_bytes(e, pPropertyCount, sizeof(*pPropertyCount)); + { uint32_t n_ = pProperties ? (uint32_t)((pPropertyCount ? *pPropertyCount : 0)) : 0; + vkb_enc_u8(e, pProperties != NULL); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; pProperties && i_ < n_; i_++) vkb_enc_out_template(e, &pProperties[i_], sizeof(VkSparseImageFormatProperties2)); + } + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pPropertyCount) vkb_dec_raw_into(d, pPropertyCount, sizeof(*pPropertyCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pProperties && pPropertyCount) ? *pPropertyCount : 0; + if (pPropertyCount) *pPropertyCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_out_struct(d, &pProperties[i_], sizeof(VkSparseImageFormatProperties2)); + } + } + vkb_call_end(&call_); +} + +VkResult vkb_wire_vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceToolProperties, vkb_table_of((const void *)physicalDevice)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)physicalDevice)); + vkb_enc_u8(e, pToolCount != NULL); + if (pToolCount) vkb_enc_bytes(e, pToolCount, sizeof(*pToolCount)); + { uint32_t n_ = pToolProperties ? (uint32_t)((pToolCount ? *pToolCount : 0)) : 0; + vkb_enc_u8(e, pToolProperties != NULL); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; pToolProperties && i_ < n_; i_++) vkb_enc_out_template(e, &pToolProperties[i_], sizeof(VkPhysicalDeviceToolProperties)); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pToolCount) vkb_dec_raw_into(d, pToolCount, sizeof(*pToolCount)); else d->err = 1; + } + { + uint32_t rn_ = vkb_dec_u32(d); + (void)rn_; + uint32_t cap_ = (pToolProperties && pToolCount) ? *pToolCount : 0; + if (pToolCount) *pToolCount = rn_; + uint32_t has_ = vkb_dec_u32(d); + for (uint32_t i_ = 0; i_ < has_; i_++) { + if (i_ >= cap_) { d->err = 1; break; } + vkb_dec_out_struct(d, &pToolProperties[i_], sizeof(VkPhysicalDeviceToolProperties)); + } + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetPipelineCacheData, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &pipelineCache, sizeof(pipelineCache)); + vkb_enc_u8(e, pDataSize != NULL); + if (pDataSize) vkb_enc_bytes(e, pDataSize, sizeof(*pDataSize)); + vkb_enc_u8(e, pData != NULL); vkb_enc_u64(e, pData ? (uint64_t)*pDataSize : 0); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pDataSize) vkb_dec_raw_into(d, pDataSize, sizeof(*pDataSize)); else d->err = 1; + } + { uint64_t sz_ = vkb_dec_u64(d); if (pDataSize) { size_t cap_ = pData ? *pDataSize : 0; *pDataSize = (size_t)sz_; vkb_dec_blob_into(d, pData, cap_); } else vkb_dec_blob_into(d, NULL, 0); } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetQueryPoolResults, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &queryPool, sizeof(queryPool)); + vkb_enc_bytes(e, &firstQuery, sizeof(firstQuery)); + vkb_enc_bytes(e, &queryCount, sizeof(queryCount)); + vkb_enc_bytes(e, &dataSize, sizeof(dataSize)); + vkb_enc_u8(e, pData != NULL); vkb_enc_u64(e, (uint64_t)(dataSize)); + vkb_enc_bytes(e, &stride, sizeof(stride)); + vkb_enc_bytes(e, &flags, sizeof(flags)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_dec_blob_into(d, pData, (size_t)(dataSize)); + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetRenderAreaGranularity, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &renderPass, sizeof(renderPass)); + vkb_enc_u8(e, pGranularity != NULL); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pGranularity) vkb_dec_raw_into(d, pGranularity, sizeof(*pGranularity)); else d->err = 1; + } + vkb_call_end(&call_); +} + +VkResult vkb_wire_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetSemaphoreCounterValue, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &semaphore, sizeof(semaphore)); + vkb_enc_u8(e, pValue != NULL); + if (pValue) vkb_enc_bytes(e, pValue, sizeof(*pValue)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + if (vkb_dec_u8(d)) { + if (pValue) vkb_dec_raw_into(d, pValue, sizeof(*pValue)); else d->err = 1; + } + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetSemaphoreFdKHR, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pGetFdInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSemaphoreGetFdInfoKHR(e, &pGetFdInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pFd != NULL); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + { int fd_ = vkb_dec_fd(d); if (pFd) *pFd = fd_; else if (fd_ >= 0) vkb_close_fd(fd_); } + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetShaderModuleCreateInfoIdentifierEXT, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkShaderModuleCreateInfo(e, &pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_u8(e, pIdentifier != NULL); + if (pIdentifier) vkb_enc_out_template(e, pIdentifier, sizeof(VkShaderModuleIdentifierEXT)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pIdentifier) vkb_dec_out_struct(d, pIdentifier, sizeof(VkShaderModuleIdentifierEXT)); else d->err = 1; + } + vkb_call_end(&call_); +} + +void vkb_wire_vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkGetShaderModuleIdentifierEXT, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &shaderModule, sizeof(shaderModule)); + vkb_enc_u8(e, pIdentifier != NULL); + if (pIdentifier) vkb_enc_out_template(e, pIdentifier, sizeof(VkShaderModuleIdentifierEXT)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + if (vkb_dec_u8(d)) { + if (pIdentifier) vkb_dec_out_struct(d, pIdentifier, sizeof(VkShaderModuleIdentifierEXT)); else d->err = 1; + } + vkb_call_end(&call_); +} + +VkResult vkb_wire_vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkImportFenceFdKHR, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pImportFenceFdInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImportFenceFdInfoKHR(e, &pImportFenceFdInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkImportSemaphoreFdKHR, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pImportSemaphoreFdInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImportSemaphoreFdInfoKHR(e, &pImportSemaphoreFdInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkInvalidateMappedMemoryRanges, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &memoryRangeCount, sizeof(memoryRangeCount)); + if (pMemoryRanges) { + uint32_t n_ = (uint32_t)(memoryRangeCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkMappedMemoryRange(e, &pMemoryRanges[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkMergePipelineCaches, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &dstCache, sizeof(dstCache)); + vkb_enc_bytes(e, &srcCacheCount, sizeof(srcCacheCount)); + if (pSrcCaches) { + uint32_t n_ = (uint32_t)(srcCacheCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pSrcCaches, (size_t)n_ * sizeof(*pSrcCaches)); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkQueueBindSparse, vkb_table_of((const void *)queue)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)queue)); + vkb_enc_bytes(e, &bindInfoCount, sizeof(bindInfoCount)); + if (pBindInfo) { + uint32_t n_ = (uint32_t)(bindInfoCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBindSparseInfo(e, &pBindInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &fence, sizeof(fence)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkQueueSubmit, vkb_table_of((const void *)queue)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)queue)); + vkb_enc_bytes(e, &submitCount, sizeof(submitCount)); + if (pSubmits) { + uint32_t n_ = (uint32_t)(submitCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSubmitInfo(e, &pSubmits[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &fence, sizeof(fence)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkQueueSubmit2, vkb_table_of((const void *)queue)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)queue)); + vkb_enc_bytes(e, &submitCount, sizeof(submitCount)); + if (pSubmits) { + uint32_t n_ = (uint32_t)(submitCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSubmitInfo2(e, &pSubmits[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &fence, sizeof(fence)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkQueueWaitIdle(VkQueue queue) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkQueueWaitIdle, vkb_table_of((const void *)queue)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)queue)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkResetCommandBuffer, vkb_table_of((const void *)commandBuffer)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)commandBuffer)); + vkb_enc_bytes(e, &flags, sizeof(flags)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkResetCommandPool, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &commandPool, sizeof(commandPool)); + vkb_enc_bytes(e, &flags, sizeof(flags)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkResetDescriptorPool, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &descriptorPool, sizeof(descriptorPool)); + vkb_enc_bytes(e, &flags, sizeof(flags)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkResetEvent(VkDevice device, VkEvent event) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkResetEvent, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &event, sizeof(event)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkResetFences, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &fenceCount, sizeof(fenceCount)); + if (pFences) { + uint32_t n_ = (uint32_t)(fenceCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pFences, (size_t)n_ * sizeof(*pFences)); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkResetQueryPool, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &queryPool, sizeof(queryPool)); + vkb_enc_bytes(e, &firstQuery, sizeof(firstQuery)); + vkb_enc_bytes(e, &queryCount, sizeof(queryCount)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkSetDeviceMemoryPriorityEXT, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &memory, sizeof(memory)); + vkb_enc_bytes(e, &priority, sizeof(priority)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +VkResult vkb_wire_vkSetEvent(VkDevice device, VkEvent event) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkSetEvent, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &event, sizeof(event)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkSignalSemaphore, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pSignalInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSemaphoreSignalInfo(e, &pSignalInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +void vkb_wire_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkTrimCommandPool, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &commandPool, sizeof(commandPool)); + vkb_enc_bytes(e, &flags, sizeof(flags)); + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +void vkb_wire_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkUpdateDescriptorSets, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &descriptorWriteCount, sizeof(descriptorWriteCount)); + if (pDescriptorWrites) { + uint32_t n_ = (uint32_t)(descriptorWriteCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkWriteDescriptorSet(e, &pDescriptorWrites[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &descriptorCopyCount, sizeof(descriptorCopyCount)); + if (pDescriptorCopies) { + uint32_t n_ = (uint32_t)(descriptorCopyCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkCopyDescriptorSet(e, &pDescriptorCopies[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (!vkb_call_exec(&call_)) { + return; + } + vkb_dec *d = &call_.d; + (void)d; + vkb_call_end(&call_); +} + +VkResult vkb_wire_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkWaitForFences, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + vkb_enc_bytes(e, &fenceCount, sizeof(fenceCount)); + if (pFences) { + uint32_t n_ = (uint32_t)(fenceCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, pFences, (size_t)n_ * sizeof(*pFences)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &waitAll, sizeof(waitAll)); + vkb_enc_bytes(e, &timeout, sizeof(timeout)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +VkResult vkb_wire_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + vkb_call call_; + vkb_call_begin(&call_, VKB_CMD_vkWaitSemaphores, vkb_table_of((const void *)device)); + vkb_enc *e = &call_.e; + vkb_enc_u64(e, vkb_remote((const void *)device)); + if (pWaitInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSemaphoreWaitInfo(e, &pWaitInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_bytes(e, &timeout, sizeof(timeout)); + if (!vkb_call_exec(&call_)) { + return VK_ERROR_DEVICE_LOST; + } + vkb_dec *d = &call_.d; + (void)d; + VkResult r_; + vkb_dec_bytes(d, &r_, sizeof(r_)); + vkb_call_end(&call_); + return r_; +} + +/* Default entry points. */ +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) +{ + return vkb_wire_vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) +{ + vkb_wire_vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + vkb_wire_vkCmdBeginQuery(commandBuffer, queryPool, query, flags); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + vkb_wire_vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + vkb_wire_vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + vkb_wire_vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + vkb_wire_vkCmdBeginRendering(commandBuffer, pRenderingInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + vkb_wire_vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + vkb_wire_vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + vkb_wire_vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + vkb_wire_vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + vkb_wire_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + vkb_wire_vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + vkb_wire_vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + vkb_wire_vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + vkb_wire_vkCmdBlitImage2(commandBuffer, pBlitImageInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + vkb_wire_vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + vkb_wire_vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + vkb_wire_vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + vkb_wire_vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + vkb_wire_vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + vkb_wire_vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + vkb_wire_vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + vkb_wire_vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + vkb_wire_vkCmdCopyImage2(commandBuffer, pCopyImageInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + vkb_wire_vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + vkb_wire_vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + vkb_wire_vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + vkb_wire_vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + vkb_wire_vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + vkb_wire_vkCmdDispatchIndirect(commandBuffer, buffer, offset); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + vkb_wire_vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + vkb_wire_vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + vkb_wire_vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + vkb_wire_vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + vkb_wire_vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + vkb_wire_vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + vkb_wire_vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) +{ + vkb_wire_vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) +{ + vkb_wire_vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) +{ + vkb_wire_vkCmdEndConditionalRenderingEXT(commandBuffer); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + vkb_wire_vkCmdEndQuery(commandBuffer, queryPool, query); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + vkb_wire_vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) +{ + vkb_wire_vkCmdEndRenderPass(commandBuffer); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + vkb_wire_vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdEndRendering(VkCommandBuffer commandBuffer) +{ + vkb_wire_vkCmdEndRendering(commandBuffer); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + vkb_wire_vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + vkb_wire_vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + vkb_wire_vkCmdNextSubpass(commandBuffer, contents); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + vkb_wire_vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + vkb_wire_vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + vkb_wire_vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + vkb_wire_vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) +{ + vkb_wire_vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + vkb_wire_vkCmdResetEvent(commandBuffer, event, stageMask); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + vkb_wire_vkCmdResetEvent2(commandBuffer, event, stageMask); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + vkb_wire_vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + vkb_wire_vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + vkb_wire_vkCmdResolveImage2(commandBuffer, pResolveImageInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) +{ + vkb_wire_vkCmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) +{ + vkb_wire_vkCmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) +{ + vkb_wire_vkCmdSetBlendConstants(commandBuffer, blendConstants); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) +{ + vkb_wire_vkCmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) +{ + vkb_wire_vkCmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) +{ + vkb_wire_vkCmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) +{ + vkb_wire_vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) +{ + vkb_wire_vkCmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) +{ + vkb_wire_vkCmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) +{ + vkb_wire_vkCmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) +{ + vkb_wire_vkCmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) +{ + vkb_wire_vkCmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) +{ + vkb_wire_vkCmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) +{ + vkb_wire_vkCmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) +{ + vkb_wire_vkCmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + vkb_wire_vkCmdSetCullMode(commandBuffer, cullMode); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + vkb_wire_vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + vkb_wire_vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + vkb_wire_vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + vkb_wire_vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) +{ + vkb_wire_vkCmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) +{ + vkb_wire_vkCmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) +{ + vkb_wire_vkCmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + vkb_wire_vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + vkb_wire_vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + vkb_wire_vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + vkb_wire_vkCmdSetDeviceMask(commandBuffer, deviceMask); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) +{ + vkb_wire_vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) +{ + vkb_wire_vkCmdSetDiscardRectangleEnableEXT(commandBuffer, discardRectangleEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) +{ + vkb_wire_vkCmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + vkb_wire_vkCmdSetEvent(commandBuffer, event, stageMask); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + vkb_wire_vkCmdSetEvent2(commandBuffer, event, pDependencyInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) +{ + vkb_wire_vkCmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) +{ + vkb_wire_vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + vkb_wire_vkCmdSetFrontFace(commandBuffer, frontFace); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) +{ + vkb_wire_vkCmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) +{ + vkb_wire_vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) +{ + vkb_wire_vkCmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) +{ + vkb_wire_vkCmdSetLineWidth(commandBuffer, lineWidth); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + vkb_wire_vkCmdSetLogicOpEXT(commandBuffer, logicOp); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) +{ + vkb_wire_vkCmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + vkb_wire_vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) +{ + vkb_wire_vkCmdSetPolygonModeEXT(commandBuffer, polygonMode); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + vkb_wire_vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + vkb_wire_vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) +{ + vkb_wire_vkCmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) +{ + vkb_wire_vkCmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) +{ + vkb_wire_vkCmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + vkb_wire_vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) +{ + vkb_wire_vkCmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) +{ + vkb_wire_vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) +{ + vkb_wire_vkCmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) +{ + vkb_wire_vkCmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + vkb_wire_vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + vkb_wire_vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) +{ + vkb_wire_vkCmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + vkb_wire_vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + vkb_wire_vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + vkb_wire_vkCmdSetStencilReference(commandBuffer, faceMask, reference); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + vkb_wire_vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + vkb_wire_vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) +{ + vkb_wire_vkCmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) +{ + vkb_wire_vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + vkb_wire_vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) +{ + vkb_wire_vkCmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) +{ + vkb_wire_vkCmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + vkb_wire_vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + vkb_wire_vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + vkb_wire_vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + vkb_wire_vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + vkb_wire_vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + vkb_wire_vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) +{ + return vkb_wire_vkCreateBufferView(device, pCreateInfo, pAllocator, pView); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) +{ + return vkb_wire_vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + return vkb_wire_vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +{ + return vkb_wire_vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +{ + return vkb_wire_vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) +{ + return vkb_wire_vkCreateEvent(device, pCreateInfo, pAllocator, pEvent); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + return vkb_wire_vkCreateFence(device, pCreateInfo, pAllocator, pFence); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +{ + return vkb_wire_vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + return vkb_wire_vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ + return vkb_wire_vkCreateImageView(device, pCreateInfo, pAllocator, pView); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +{ + return vkb_wire_vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +{ + return vkb_wire_vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) +{ + return vkb_wire_vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + return vkb_wire_vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + return vkb_wire_vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) +{ + return vkb_wire_vkCreateSampler(device, pCreateInfo, pAllocator, pSampler); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + return vkb_wire_vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) +{ + return vkb_wire_vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) +{ + return vkb_wire_vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyBufferView(device, bufferView, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyDescriptorPool(device, descriptorPool, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyEvent(device, event, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyFence(device, fence, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyFramebuffer(device, framebuffer, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyImageView(device, imageView, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyPipeline(device, pipeline, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyPipelineCache(device, pipelineCache, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyPipelineLayout(device, pipelineLayout, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyQueryPool(device, queryPool, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyRenderPass(device, renderPass, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroySampler(device, sampler, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroySemaphore(device, semaphore, pAllocator); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + vkb_wire_vkDestroyShaderModule(device, shaderModule, pAllocator); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) +{ + return vkb_wire_vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); +} + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkb_ep_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + return vkb_wire_vkGetBufferDeviceAddress(device, pInfo); +} + +static VKAPI_ATTR uint64_t VKAPI_CALL vkb_ep_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + return vkb_wire_vkGetBufferOpaqueCaptureAddress(device, pInfo); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) +{ + return vkb_wire_vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + vkb_wire_vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + vkb_wire_vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + vkb_wire_vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); +} + +static VKAPI_ATTR uint64_t VKAPI_CALL vkb_ep_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + return vkb_wire_vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetEventStatus(VkDevice device, VkEvent event) +{ + return vkb_wire_vkGetEventStatus(device, event); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + return vkb_wire_vkGetFenceFdKHR(device, pGetFdInfo, pFd); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ + return vkb_wire_vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout) +{ + vkb_wire_vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + return vkb_wire_vkGetMemoryFdKHR(device, pGetFdInfo, pFd); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) +{ + return vkb_wire_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) +{ + return vkb_wire_vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) +{ + return vkb_wire_vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) +{ + return vkb_wire_vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + vkb_wire_vkGetRenderAreaGranularity(device, renderPass, pGranularity); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + return vkb_wire_vkGetSemaphoreFdKHR(device, pGetFdInfo, pFd); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) +{ + vkb_wire_vkGetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) +{ + vkb_wire_vkGetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) +{ + return vkb_wire_vkImportFenceFdKHR(device, pImportFenceFdInfo); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) +{ + return vkb_wire_vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +{ + return vkb_wire_vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ + return vkb_wire_vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) +{ + return vkb_wire_vkResetDescriptorPool(device, descriptorPool, flags); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetEvent(VkDevice device, VkEvent event) +{ + return vkb_wire_vkResetEvent(device, event); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) +{ + return vkb_wire_vkResetFences(device, fenceCount, pFences); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + vkb_wire_vkResetQueryPool(device, queryPool, firstQuery, queryCount); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) +{ + vkb_wire_vkSetDeviceMemoryPriorityEXT(device, memory, priority); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetEvent(VkDevice device, VkEvent event) +{ + return vkb_wire_vkSetEvent(device, event); +} + +static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + return vkb_wire_vkSignalSemaphore(device, pSignalInfo); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + vkb_wire_vkTrimCommandPool(device, commandPool, flags); +} + +static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + vkb_wire_vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); +} + +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"}, + {"vkCmdBeginConditionalRenderingEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginConditionalRenderingEXT, VKB_LEVEL_DEVICE, "VK_EXT_conditional_rendering"}, + {"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}, + {"vkCmdBindIndexBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdBindIndexBuffer, VKB_LEVEL_DEVICE, NULL}, + {"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}, + {"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}, + {"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}, + {"vkCmdPushDescriptorSetKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetKHR, VKB_LEVEL_DEVICE, "VK_KHR_push_descriptor"}, + {"vkCmdPushDescriptorSetWithTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplateKHR, 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"}, + {"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"}, + {"vkCmdSetCoverageModulationModeNV", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCoverageModulationModeNV, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, + {"vkCmdSetCoverageModulationTableEnableNV", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCoverageModulationTableEnableNV, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, + {"vkCmdSetCoverageModulationTableNV", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCoverageModulationTableNV, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, + {"vkCmdSetCoverageReductionModeNV", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCoverageReductionModeNV, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, + {"vkCmdSetCoverageToColorEnableNV", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCoverageToColorEnableNV, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, + {"vkCmdSetCoverageToColorLocationNV", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCoverageToColorLocationNV, 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}, + {"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"}, + {"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"}, + {"vkCmdSetLineStippleEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStippleEXT, VKB_LEVEL_DEVICE, "VK_EXT_line_rasterization"}, + {"vkCmdSetLineStippleEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStippleEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, + {"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"}, + {"vkCmdSetRepresentativeFragmentTestEnableNV", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRepresentativeFragmentTestEnableNV, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, + {"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"}, + {"vkCmdSetShadingRateImageEnableNV", (PFN_vkVoidFunction)vkb_ep_vkCmdSetShadingRateImageEnableNV, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, + {"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}, + {"vkCmdSetViewportSwizzleNV", (PFN_vkVoidFunction)vkb_ep_vkCmdSetViewportSwizzleNV, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, + {"vkCmdSetViewportWScalingEnableNV", (PFN_vkVoidFunction)vkb_ep_vkCmdSetViewportWScalingEnableNV, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, + {"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"}, + {"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"}, + {"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"}, + {"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"}, + {"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_vkGetCalibratedTimestampsEXT, 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"}, + {"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}, + {"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}, + {"vkGetImageSubresourceLayout2EXT", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout2EXT, VKB_LEVEL_DEVICE, "VK_EXT_image_compression_control"}, + {"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_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, VKB_LEVEL_PHYSDEV, "VK_EXT_calibrated_timestamps"}, + {"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"}, + {"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}, + {"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"}, + {"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}, + {"vkMapMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkMapMemory2KHR, 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"}, + {"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}, + {"vkUnmapMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkUnmapMemory2KHR, 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"}, +}; +const size_t vkb_client_proc_count = sizeof(vkb_client_procs) / sizeof(vkb_client_procs[0]); diff --git a/tools/vkbridge/common/gen/vkb_gen_server.c b/tools/vkbridge/common/gen/vkb_gen_server.c new file mode 100644 index 000000000..5c7c04edf --- /dev/null +++ b/tools/vkbridge/common/gen/vkb_gen_server.c @@ -0,0 +1,7217 @@ +/* Generated by tools/vkbridge/codegen/gen_vkbridge.py from vk.xml 1.3.247 - do not edit. */ + +#include "vkb_gen.h" +#include "../vkb_wire.h" +#include "vkb_server_gen.h" +#include "../vkb_server_iface.h" +#include + +void vkb_dispatch_load_instance(vkb_dispatch *dt, PFN_vkGetInstanceProcAddr gipa, VkInstance instance) +{ + dt->vkAllocateCommandBuffers = (PFN_vkAllocateCommandBuffers)gipa(instance, "vkAllocateCommandBuffers"); + dt->vkAllocateDescriptorSets = (PFN_vkAllocateDescriptorSets)gipa(instance, "vkAllocateDescriptorSets"); + dt->vkAllocateMemory = (PFN_vkAllocateMemory)gipa(instance, "vkAllocateMemory"); + dt->vkBeginCommandBuffer = (PFN_vkBeginCommandBuffer)gipa(instance, "vkBeginCommandBuffer"); + dt->vkBindBufferMemory = (PFN_vkBindBufferMemory)gipa(instance, "vkBindBufferMemory"); + dt->vkBindBufferMemory2 = (PFN_vkBindBufferMemory2)gipa(instance, "vkBindBufferMemory2"); + if (!dt->vkBindBufferMemory2) dt->vkBindBufferMemory2 = (PFN_vkBindBufferMemory2)gipa(instance, "vkBindBufferMemory2KHR"); + dt->vkBindImageMemory = (PFN_vkBindImageMemory)gipa(instance, "vkBindImageMemory"); + dt->vkBindImageMemory2 = (PFN_vkBindImageMemory2)gipa(instance, "vkBindImageMemory2"); + if (!dt->vkBindImageMemory2) dt->vkBindImageMemory2 = (PFN_vkBindImageMemory2)gipa(instance, "vkBindImageMemory2KHR"); + dt->vkCmdBeginConditionalRenderingEXT = (PFN_vkCmdBeginConditionalRenderingEXT)gipa(instance, "vkCmdBeginConditionalRenderingEXT"); + dt->vkCmdBeginQuery = (PFN_vkCmdBeginQuery)gipa(instance, "vkCmdBeginQuery"); + dt->vkCmdBeginQueryIndexedEXT = (PFN_vkCmdBeginQueryIndexedEXT)gipa(instance, "vkCmdBeginQueryIndexedEXT"); + dt->vkCmdBeginRenderPass = (PFN_vkCmdBeginRenderPass)gipa(instance, "vkCmdBeginRenderPass"); + dt->vkCmdBeginRenderPass2 = (PFN_vkCmdBeginRenderPass2)gipa(instance, "vkCmdBeginRenderPass2"); + if (!dt->vkCmdBeginRenderPass2) dt->vkCmdBeginRenderPass2 = (PFN_vkCmdBeginRenderPass2)gipa(instance, "vkCmdBeginRenderPass2KHR"); + dt->vkCmdBeginRendering = (PFN_vkCmdBeginRendering)gipa(instance, "vkCmdBeginRendering"); + if (!dt->vkCmdBeginRendering) dt->vkCmdBeginRendering = (PFN_vkCmdBeginRendering)gipa(instance, "vkCmdBeginRenderingKHR"); + dt->vkCmdBeginTransformFeedbackEXT = (PFN_vkCmdBeginTransformFeedbackEXT)gipa(instance, "vkCmdBeginTransformFeedbackEXT"); + dt->vkCmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets)gipa(instance, "vkCmdBindDescriptorSets"); + dt->vkCmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer)gipa(instance, "vkCmdBindIndexBuffer"); + dt->vkCmdBindPipeline = (PFN_vkCmdBindPipeline)gipa(instance, "vkCmdBindPipeline"); + dt->vkCmdBindTransformFeedbackBuffersEXT = (PFN_vkCmdBindTransformFeedbackBuffersEXT)gipa(instance, "vkCmdBindTransformFeedbackBuffersEXT"); + dt->vkCmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers)gipa(instance, "vkCmdBindVertexBuffers"); + dt->vkCmdBindVertexBuffers2 = (PFN_vkCmdBindVertexBuffers2)gipa(instance, "vkCmdBindVertexBuffers2"); + if (!dt->vkCmdBindVertexBuffers2) dt->vkCmdBindVertexBuffers2 = (PFN_vkCmdBindVertexBuffers2)gipa(instance, "vkCmdBindVertexBuffers2EXT"); + dt->vkCmdBlitImage = (PFN_vkCmdBlitImage)gipa(instance, "vkCmdBlitImage"); + dt->vkCmdBlitImage2 = (PFN_vkCmdBlitImage2)gipa(instance, "vkCmdBlitImage2"); + if (!dt->vkCmdBlitImage2) dt->vkCmdBlitImage2 = (PFN_vkCmdBlitImage2)gipa(instance, "vkCmdBlitImage2KHR"); + dt->vkCmdClearAttachments = (PFN_vkCmdClearAttachments)gipa(instance, "vkCmdClearAttachments"); + dt->vkCmdClearColorImage = (PFN_vkCmdClearColorImage)gipa(instance, "vkCmdClearColorImage"); + dt->vkCmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage)gipa(instance, "vkCmdClearDepthStencilImage"); + dt->vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer)gipa(instance, "vkCmdCopyBuffer"); + dt->vkCmdCopyBuffer2 = (PFN_vkCmdCopyBuffer2)gipa(instance, "vkCmdCopyBuffer2"); + if (!dt->vkCmdCopyBuffer2) dt->vkCmdCopyBuffer2 = (PFN_vkCmdCopyBuffer2)gipa(instance, "vkCmdCopyBuffer2KHR"); + dt->vkCmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage)gipa(instance, "vkCmdCopyBufferToImage"); + dt->vkCmdCopyBufferToImage2 = (PFN_vkCmdCopyBufferToImage2)gipa(instance, "vkCmdCopyBufferToImage2"); + if (!dt->vkCmdCopyBufferToImage2) dt->vkCmdCopyBufferToImage2 = (PFN_vkCmdCopyBufferToImage2)gipa(instance, "vkCmdCopyBufferToImage2KHR"); + dt->vkCmdCopyImage = (PFN_vkCmdCopyImage)gipa(instance, "vkCmdCopyImage"); + dt->vkCmdCopyImage2 = (PFN_vkCmdCopyImage2)gipa(instance, "vkCmdCopyImage2"); + if (!dt->vkCmdCopyImage2) dt->vkCmdCopyImage2 = (PFN_vkCmdCopyImage2)gipa(instance, "vkCmdCopyImage2KHR"); + dt->vkCmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer)gipa(instance, "vkCmdCopyImageToBuffer"); + dt->vkCmdCopyImageToBuffer2 = (PFN_vkCmdCopyImageToBuffer2)gipa(instance, "vkCmdCopyImageToBuffer2"); + if (!dt->vkCmdCopyImageToBuffer2) dt->vkCmdCopyImageToBuffer2 = (PFN_vkCmdCopyImageToBuffer2)gipa(instance, "vkCmdCopyImageToBuffer2KHR"); + dt->vkCmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults)gipa(instance, "vkCmdCopyQueryPoolResults"); + dt->vkCmdDispatch = (PFN_vkCmdDispatch)gipa(instance, "vkCmdDispatch"); + dt->vkCmdDispatchBase = (PFN_vkCmdDispatchBase)gipa(instance, "vkCmdDispatchBase"); + if (!dt->vkCmdDispatchBase) dt->vkCmdDispatchBase = (PFN_vkCmdDispatchBase)gipa(instance, "vkCmdDispatchBaseKHR"); + dt->vkCmdDispatchIndirect = (PFN_vkCmdDispatchIndirect)gipa(instance, "vkCmdDispatchIndirect"); + dt->vkCmdDraw = (PFN_vkCmdDraw)gipa(instance, "vkCmdDraw"); + dt->vkCmdDrawIndexed = (PFN_vkCmdDrawIndexed)gipa(instance, "vkCmdDrawIndexed"); + dt->vkCmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect)gipa(instance, "vkCmdDrawIndexedIndirect"); + dt->vkCmdDrawIndexedIndirectCount = (PFN_vkCmdDrawIndexedIndirectCount)gipa(instance, "vkCmdDrawIndexedIndirectCount"); + if (!dt->vkCmdDrawIndexedIndirectCount) dt->vkCmdDrawIndexedIndirectCount = (PFN_vkCmdDrawIndexedIndirectCount)gipa(instance, "vkCmdDrawIndexedIndirectCountAMD"); + if (!dt->vkCmdDrawIndexedIndirectCount) dt->vkCmdDrawIndexedIndirectCount = (PFN_vkCmdDrawIndexedIndirectCount)gipa(instance, "vkCmdDrawIndexedIndirectCountKHR"); + dt->vkCmdDrawIndirect = (PFN_vkCmdDrawIndirect)gipa(instance, "vkCmdDrawIndirect"); + dt->vkCmdDrawIndirectByteCountEXT = (PFN_vkCmdDrawIndirectByteCountEXT)gipa(instance, "vkCmdDrawIndirectByteCountEXT"); + dt->vkCmdDrawIndirectCount = (PFN_vkCmdDrawIndirectCount)gipa(instance, "vkCmdDrawIndirectCount"); + if (!dt->vkCmdDrawIndirectCount) dt->vkCmdDrawIndirectCount = (PFN_vkCmdDrawIndirectCount)gipa(instance, "vkCmdDrawIndirectCountAMD"); + if (!dt->vkCmdDrawIndirectCount) dt->vkCmdDrawIndirectCount = (PFN_vkCmdDrawIndirectCount)gipa(instance, "vkCmdDrawIndirectCountKHR"); + dt->vkCmdDrawMultiEXT = (PFN_vkCmdDrawMultiEXT)gipa(instance, "vkCmdDrawMultiEXT"); + dt->vkCmdDrawMultiIndexedEXT = (PFN_vkCmdDrawMultiIndexedEXT)gipa(instance, "vkCmdDrawMultiIndexedEXT"); + dt->vkCmdEndConditionalRenderingEXT = (PFN_vkCmdEndConditionalRenderingEXT)gipa(instance, "vkCmdEndConditionalRenderingEXT"); + dt->vkCmdEndQuery = (PFN_vkCmdEndQuery)gipa(instance, "vkCmdEndQuery"); + dt->vkCmdEndQueryIndexedEXT = (PFN_vkCmdEndQueryIndexedEXT)gipa(instance, "vkCmdEndQueryIndexedEXT"); + dt->vkCmdEndRenderPass = (PFN_vkCmdEndRenderPass)gipa(instance, "vkCmdEndRenderPass"); + dt->vkCmdEndRenderPass2 = (PFN_vkCmdEndRenderPass2)gipa(instance, "vkCmdEndRenderPass2"); + if (!dt->vkCmdEndRenderPass2) dt->vkCmdEndRenderPass2 = (PFN_vkCmdEndRenderPass2)gipa(instance, "vkCmdEndRenderPass2KHR"); + dt->vkCmdEndRendering = (PFN_vkCmdEndRendering)gipa(instance, "vkCmdEndRendering"); + if (!dt->vkCmdEndRendering) dt->vkCmdEndRendering = (PFN_vkCmdEndRendering)gipa(instance, "vkCmdEndRenderingKHR"); + dt->vkCmdEndTransformFeedbackEXT = (PFN_vkCmdEndTransformFeedbackEXT)gipa(instance, "vkCmdEndTransformFeedbackEXT"); + dt->vkCmdExecuteCommands = (PFN_vkCmdExecuteCommands)gipa(instance, "vkCmdExecuteCommands"); + dt->vkCmdFillBuffer = (PFN_vkCmdFillBuffer)gipa(instance, "vkCmdFillBuffer"); + dt->vkCmdNextSubpass = (PFN_vkCmdNextSubpass)gipa(instance, "vkCmdNextSubpass"); + dt->vkCmdNextSubpass2 = (PFN_vkCmdNextSubpass2)gipa(instance, "vkCmdNextSubpass2"); + if (!dt->vkCmdNextSubpass2) dt->vkCmdNextSubpass2 = (PFN_vkCmdNextSubpass2)gipa(instance, "vkCmdNextSubpass2KHR"); + dt->vkCmdPipelineBarrier = (PFN_vkCmdPipelineBarrier)gipa(instance, "vkCmdPipelineBarrier"); + dt->vkCmdPipelineBarrier2 = (PFN_vkCmdPipelineBarrier2)gipa(instance, "vkCmdPipelineBarrier2"); + if (!dt->vkCmdPipelineBarrier2) dt->vkCmdPipelineBarrier2 = (PFN_vkCmdPipelineBarrier2)gipa(instance, "vkCmdPipelineBarrier2KHR"); + dt->vkCmdPushConstants = (PFN_vkCmdPushConstants)gipa(instance, "vkCmdPushConstants"); + dt->vkCmdPushDescriptorSetKHR = (PFN_vkCmdPushDescriptorSetKHR)gipa(instance, "vkCmdPushDescriptorSetKHR"); + dt->vkCmdPushDescriptorSetWithTemplateKHR = (PFN_vkCmdPushDescriptorSetWithTemplateKHR)gipa(instance, "vkCmdPushDescriptorSetWithTemplateKHR"); + dt->vkCmdResetEvent = (PFN_vkCmdResetEvent)gipa(instance, "vkCmdResetEvent"); + dt->vkCmdResetEvent2 = (PFN_vkCmdResetEvent2)gipa(instance, "vkCmdResetEvent2"); + if (!dt->vkCmdResetEvent2) dt->vkCmdResetEvent2 = (PFN_vkCmdResetEvent2)gipa(instance, "vkCmdResetEvent2KHR"); + dt->vkCmdResetQueryPool = (PFN_vkCmdResetQueryPool)gipa(instance, "vkCmdResetQueryPool"); + dt->vkCmdResolveImage = (PFN_vkCmdResolveImage)gipa(instance, "vkCmdResolveImage"); + dt->vkCmdResolveImage2 = (PFN_vkCmdResolveImage2)gipa(instance, "vkCmdResolveImage2"); + if (!dt->vkCmdResolveImage2) dt->vkCmdResolveImage2 = (PFN_vkCmdResolveImage2)gipa(instance, "vkCmdResolveImage2KHR"); + dt->vkCmdSetAlphaToCoverageEnableEXT = (PFN_vkCmdSetAlphaToCoverageEnableEXT)gipa(instance, "vkCmdSetAlphaToCoverageEnableEXT"); + dt->vkCmdSetAlphaToOneEnableEXT = (PFN_vkCmdSetAlphaToOneEnableEXT)gipa(instance, "vkCmdSetAlphaToOneEnableEXT"); + dt->vkCmdSetBlendConstants = (PFN_vkCmdSetBlendConstants)gipa(instance, "vkCmdSetBlendConstants"); + dt->vkCmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)gipa(instance, "vkCmdSetColorBlendAdvancedEXT"); + dt->vkCmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT)gipa(instance, "vkCmdSetColorBlendEnableEXT"); + dt->vkCmdSetColorBlendEquationEXT = (PFN_vkCmdSetColorBlendEquationEXT)gipa(instance, "vkCmdSetColorBlendEquationEXT"); + dt->vkCmdSetColorWriteEnableEXT = (PFN_vkCmdSetColorWriteEnableEXT)gipa(instance, "vkCmdSetColorWriteEnableEXT"); + dt->vkCmdSetColorWriteMaskEXT = (PFN_vkCmdSetColorWriteMaskEXT)gipa(instance, "vkCmdSetColorWriteMaskEXT"); + dt->vkCmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)gipa(instance, "vkCmdSetConservativeRasterizationModeEXT"); + dt->vkCmdSetCoverageModulationModeNV = (PFN_vkCmdSetCoverageModulationModeNV)gipa(instance, "vkCmdSetCoverageModulationModeNV"); + dt->vkCmdSetCoverageModulationTableEnableNV = (PFN_vkCmdSetCoverageModulationTableEnableNV)gipa(instance, "vkCmdSetCoverageModulationTableEnableNV"); + dt->vkCmdSetCoverageModulationTableNV = (PFN_vkCmdSetCoverageModulationTableNV)gipa(instance, "vkCmdSetCoverageModulationTableNV"); + dt->vkCmdSetCoverageReductionModeNV = (PFN_vkCmdSetCoverageReductionModeNV)gipa(instance, "vkCmdSetCoverageReductionModeNV"); + dt->vkCmdSetCoverageToColorEnableNV = (PFN_vkCmdSetCoverageToColorEnableNV)gipa(instance, "vkCmdSetCoverageToColorEnableNV"); + dt->vkCmdSetCoverageToColorLocationNV = (PFN_vkCmdSetCoverageToColorLocationNV)gipa(instance, "vkCmdSetCoverageToColorLocationNV"); + dt->vkCmdSetCullMode = (PFN_vkCmdSetCullMode)gipa(instance, "vkCmdSetCullMode"); + if (!dt->vkCmdSetCullMode) dt->vkCmdSetCullMode = (PFN_vkCmdSetCullMode)gipa(instance, "vkCmdSetCullModeEXT"); + dt->vkCmdSetDepthBias = (PFN_vkCmdSetDepthBias)gipa(instance, "vkCmdSetDepthBias"); + dt->vkCmdSetDepthBiasEnable = (PFN_vkCmdSetDepthBiasEnable)gipa(instance, "vkCmdSetDepthBiasEnable"); + if (!dt->vkCmdSetDepthBiasEnable) dt->vkCmdSetDepthBiasEnable = (PFN_vkCmdSetDepthBiasEnable)gipa(instance, "vkCmdSetDepthBiasEnableEXT"); + dt->vkCmdSetDepthBounds = (PFN_vkCmdSetDepthBounds)gipa(instance, "vkCmdSetDepthBounds"); + dt->vkCmdSetDepthBoundsTestEnable = (PFN_vkCmdSetDepthBoundsTestEnable)gipa(instance, "vkCmdSetDepthBoundsTestEnable"); + if (!dt->vkCmdSetDepthBoundsTestEnable) dt->vkCmdSetDepthBoundsTestEnable = (PFN_vkCmdSetDepthBoundsTestEnable)gipa(instance, "vkCmdSetDepthBoundsTestEnableEXT"); + dt->vkCmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT)gipa(instance, "vkCmdSetDepthClampEnableEXT"); + dt->vkCmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)gipa(instance, "vkCmdSetDepthClipEnableEXT"); + dt->vkCmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)gipa(instance, "vkCmdSetDepthClipNegativeOneToOneEXT"); + dt->vkCmdSetDepthCompareOp = (PFN_vkCmdSetDepthCompareOp)gipa(instance, "vkCmdSetDepthCompareOp"); + if (!dt->vkCmdSetDepthCompareOp) dt->vkCmdSetDepthCompareOp = (PFN_vkCmdSetDepthCompareOp)gipa(instance, "vkCmdSetDepthCompareOpEXT"); + dt->vkCmdSetDepthTestEnable = (PFN_vkCmdSetDepthTestEnable)gipa(instance, "vkCmdSetDepthTestEnable"); + if (!dt->vkCmdSetDepthTestEnable) dt->vkCmdSetDepthTestEnable = (PFN_vkCmdSetDepthTestEnable)gipa(instance, "vkCmdSetDepthTestEnableEXT"); + dt->vkCmdSetDepthWriteEnable = (PFN_vkCmdSetDepthWriteEnable)gipa(instance, "vkCmdSetDepthWriteEnable"); + if (!dt->vkCmdSetDepthWriteEnable) dt->vkCmdSetDepthWriteEnable = (PFN_vkCmdSetDepthWriteEnable)gipa(instance, "vkCmdSetDepthWriteEnableEXT"); + dt->vkCmdSetDeviceMask = (PFN_vkCmdSetDeviceMask)gipa(instance, "vkCmdSetDeviceMask"); + if (!dt->vkCmdSetDeviceMask) dt->vkCmdSetDeviceMask = (PFN_vkCmdSetDeviceMask)gipa(instance, "vkCmdSetDeviceMaskKHR"); + dt->vkCmdSetDiscardRectangleEXT = (PFN_vkCmdSetDiscardRectangleEXT)gipa(instance, "vkCmdSetDiscardRectangleEXT"); + dt->vkCmdSetDiscardRectangleEnableEXT = (PFN_vkCmdSetDiscardRectangleEnableEXT)gipa(instance, "vkCmdSetDiscardRectangleEnableEXT"); + dt->vkCmdSetDiscardRectangleModeEXT = (PFN_vkCmdSetDiscardRectangleModeEXT)gipa(instance, "vkCmdSetDiscardRectangleModeEXT"); + dt->vkCmdSetEvent = (PFN_vkCmdSetEvent)gipa(instance, "vkCmdSetEvent"); + dt->vkCmdSetEvent2 = (PFN_vkCmdSetEvent2)gipa(instance, "vkCmdSetEvent2"); + if (!dt->vkCmdSetEvent2) dt->vkCmdSetEvent2 = (PFN_vkCmdSetEvent2)gipa(instance, "vkCmdSetEvent2KHR"); + dt->vkCmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)gipa(instance, "vkCmdSetExtraPrimitiveOverestimationSizeEXT"); + dt->vkCmdSetFragmentShadingRateKHR = (PFN_vkCmdSetFragmentShadingRateKHR)gipa(instance, "vkCmdSetFragmentShadingRateKHR"); + dt->vkCmdSetFrontFace = (PFN_vkCmdSetFrontFace)gipa(instance, "vkCmdSetFrontFace"); + if (!dt->vkCmdSetFrontFace) dt->vkCmdSetFrontFace = (PFN_vkCmdSetFrontFace)gipa(instance, "vkCmdSetFrontFaceEXT"); + dt->vkCmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT)gipa(instance, "vkCmdSetLineRasterizationModeEXT"); + dt->vkCmdSetLineStippleEXT = (PFN_vkCmdSetLineStippleEXT)gipa(instance, "vkCmdSetLineStippleEXT"); + dt->vkCmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)gipa(instance, "vkCmdSetLineStippleEnableEXT"); + dt->vkCmdSetLineWidth = (PFN_vkCmdSetLineWidth)gipa(instance, "vkCmdSetLineWidth"); + dt->vkCmdSetLogicOpEXT = (PFN_vkCmdSetLogicOpEXT)gipa(instance, "vkCmdSetLogicOpEXT"); + dt->vkCmdSetLogicOpEnableEXT = (PFN_vkCmdSetLogicOpEnableEXT)gipa(instance, "vkCmdSetLogicOpEnableEXT"); + dt->vkCmdSetPatchControlPointsEXT = (PFN_vkCmdSetPatchControlPointsEXT)gipa(instance, "vkCmdSetPatchControlPointsEXT"); + dt->vkCmdSetPolygonModeEXT = (PFN_vkCmdSetPolygonModeEXT)gipa(instance, "vkCmdSetPolygonModeEXT"); + dt->vkCmdSetPrimitiveRestartEnable = (PFN_vkCmdSetPrimitiveRestartEnable)gipa(instance, "vkCmdSetPrimitiveRestartEnable"); + if (!dt->vkCmdSetPrimitiveRestartEnable) dt->vkCmdSetPrimitiveRestartEnable = (PFN_vkCmdSetPrimitiveRestartEnable)gipa(instance, "vkCmdSetPrimitiveRestartEnableEXT"); + dt->vkCmdSetPrimitiveTopology = (PFN_vkCmdSetPrimitiveTopology)gipa(instance, "vkCmdSetPrimitiveTopology"); + if (!dt->vkCmdSetPrimitiveTopology) dt->vkCmdSetPrimitiveTopology = (PFN_vkCmdSetPrimitiveTopology)gipa(instance, "vkCmdSetPrimitiveTopologyEXT"); + dt->vkCmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT)gipa(instance, "vkCmdSetProvokingVertexModeEXT"); + dt->vkCmdSetRasterizationSamplesEXT = (PFN_vkCmdSetRasterizationSamplesEXT)gipa(instance, "vkCmdSetRasterizationSamplesEXT"); + dt->vkCmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)gipa(instance, "vkCmdSetRasterizationStreamEXT"); + dt->vkCmdSetRasterizerDiscardEnable = (PFN_vkCmdSetRasterizerDiscardEnable)gipa(instance, "vkCmdSetRasterizerDiscardEnable"); + if (!dt->vkCmdSetRasterizerDiscardEnable) dt->vkCmdSetRasterizerDiscardEnable = (PFN_vkCmdSetRasterizerDiscardEnable)gipa(instance, "vkCmdSetRasterizerDiscardEnableEXT"); + dt->vkCmdSetRepresentativeFragmentTestEnableNV = (PFN_vkCmdSetRepresentativeFragmentTestEnableNV)gipa(instance, "vkCmdSetRepresentativeFragmentTestEnableNV"); + dt->vkCmdSetSampleLocationsEXT = (PFN_vkCmdSetSampleLocationsEXT)gipa(instance, "vkCmdSetSampleLocationsEXT"); + dt->vkCmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT)gipa(instance, "vkCmdSetSampleLocationsEnableEXT"); + dt->vkCmdSetSampleMaskEXT = (PFN_vkCmdSetSampleMaskEXT)gipa(instance, "vkCmdSetSampleMaskEXT"); + dt->vkCmdSetScissor = (PFN_vkCmdSetScissor)gipa(instance, "vkCmdSetScissor"); + dt->vkCmdSetScissorWithCount = (PFN_vkCmdSetScissorWithCount)gipa(instance, "vkCmdSetScissorWithCount"); + if (!dt->vkCmdSetScissorWithCount) dt->vkCmdSetScissorWithCount = (PFN_vkCmdSetScissorWithCount)gipa(instance, "vkCmdSetScissorWithCountEXT"); + dt->vkCmdSetShadingRateImageEnableNV = (PFN_vkCmdSetShadingRateImageEnableNV)gipa(instance, "vkCmdSetShadingRateImageEnableNV"); + dt->vkCmdSetStencilCompareMask = (PFN_vkCmdSetStencilCompareMask)gipa(instance, "vkCmdSetStencilCompareMask"); + dt->vkCmdSetStencilOp = (PFN_vkCmdSetStencilOp)gipa(instance, "vkCmdSetStencilOp"); + if (!dt->vkCmdSetStencilOp) dt->vkCmdSetStencilOp = (PFN_vkCmdSetStencilOp)gipa(instance, "vkCmdSetStencilOpEXT"); + dt->vkCmdSetStencilReference = (PFN_vkCmdSetStencilReference)gipa(instance, "vkCmdSetStencilReference"); + dt->vkCmdSetStencilTestEnable = (PFN_vkCmdSetStencilTestEnable)gipa(instance, "vkCmdSetStencilTestEnable"); + if (!dt->vkCmdSetStencilTestEnable) dt->vkCmdSetStencilTestEnable = (PFN_vkCmdSetStencilTestEnable)gipa(instance, "vkCmdSetStencilTestEnableEXT"); + dt->vkCmdSetStencilWriteMask = (PFN_vkCmdSetStencilWriteMask)gipa(instance, "vkCmdSetStencilWriteMask"); + dt->vkCmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)gipa(instance, "vkCmdSetTessellationDomainOriginEXT"); + dt->vkCmdSetVertexInputEXT = (PFN_vkCmdSetVertexInputEXT)gipa(instance, "vkCmdSetVertexInputEXT"); + dt->vkCmdSetViewport = (PFN_vkCmdSetViewport)gipa(instance, "vkCmdSetViewport"); + dt->vkCmdSetViewportSwizzleNV = (PFN_vkCmdSetViewportSwizzleNV)gipa(instance, "vkCmdSetViewportSwizzleNV"); + dt->vkCmdSetViewportWScalingEnableNV = (PFN_vkCmdSetViewportWScalingEnableNV)gipa(instance, "vkCmdSetViewportWScalingEnableNV"); + dt->vkCmdSetViewportWithCount = (PFN_vkCmdSetViewportWithCount)gipa(instance, "vkCmdSetViewportWithCount"); + if (!dt->vkCmdSetViewportWithCount) dt->vkCmdSetViewportWithCount = (PFN_vkCmdSetViewportWithCount)gipa(instance, "vkCmdSetViewportWithCountEXT"); + dt->vkCmdUpdateBuffer = (PFN_vkCmdUpdateBuffer)gipa(instance, "vkCmdUpdateBuffer"); + dt->vkCmdWaitEvents = (PFN_vkCmdWaitEvents)gipa(instance, "vkCmdWaitEvents"); + dt->vkCmdWaitEvents2 = (PFN_vkCmdWaitEvents2)gipa(instance, "vkCmdWaitEvents2"); + if (!dt->vkCmdWaitEvents2) dt->vkCmdWaitEvents2 = (PFN_vkCmdWaitEvents2)gipa(instance, "vkCmdWaitEvents2KHR"); + dt->vkCmdWriteTimestamp = (PFN_vkCmdWriteTimestamp)gipa(instance, "vkCmdWriteTimestamp"); + dt->vkCmdWriteTimestamp2 = (PFN_vkCmdWriteTimestamp2)gipa(instance, "vkCmdWriteTimestamp2"); + if (!dt->vkCmdWriteTimestamp2) dt->vkCmdWriteTimestamp2 = (PFN_vkCmdWriteTimestamp2)gipa(instance, "vkCmdWriteTimestamp2KHR"); + dt->vkCreateBuffer = (PFN_vkCreateBuffer)gipa(instance, "vkCreateBuffer"); + dt->vkCreateBufferView = (PFN_vkCreateBufferView)gipa(instance, "vkCreateBufferView"); + dt->vkCreateCommandPool = (PFN_vkCreateCommandPool)gipa(instance, "vkCreateCommandPool"); + dt->vkCreateComputePipelines = (PFN_vkCreateComputePipelines)gipa(instance, "vkCreateComputePipelines"); + dt->vkCreateDescriptorPool = (PFN_vkCreateDescriptorPool)gipa(instance, "vkCreateDescriptorPool"); + dt->vkCreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout)gipa(instance, "vkCreateDescriptorSetLayout"); + dt->vkCreateDescriptorUpdateTemplate = (PFN_vkCreateDescriptorUpdateTemplate)gipa(instance, "vkCreateDescriptorUpdateTemplate"); + if (!dt->vkCreateDescriptorUpdateTemplate) dt->vkCreateDescriptorUpdateTemplate = (PFN_vkCreateDescriptorUpdateTemplate)gipa(instance, "vkCreateDescriptorUpdateTemplateKHR"); + dt->vkCreateDevice = (PFN_vkCreateDevice)gipa(instance, "vkCreateDevice"); + dt->vkCreateEvent = (PFN_vkCreateEvent)gipa(instance, "vkCreateEvent"); + dt->vkCreateFence = (PFN_vkCreateFence)gipa(instance, "vkCreateFence"); + dt->vkCreateFramebuffer = (PFN_vkCreateFramebuffer)gipa(instance, "vkCreateFramebuffer"); + dt->vkCreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines)gipa(instance, "vkCreateGraphicsPipelines"); + dt->vkCreateImage = (PFN_vkCreateImage)gipa(instance, "vkCreateImage"); + dt->vkCreateImageView = (PFN_vkCreateImageView)gipa(instance, "vkCreateImageView"); + dt->vkCreateInstance = (PFN_vkCreateInstance)gipa(instance, "vkCreateInstance"); + dt->vkCreatePipelineCache = (PFN_vkCreatePipelineCache)gipa(instance, "vkCreatePipelineCache"); + dt->vkCreatePipelineLayout = (PFN_vkCreatePipelineLayout)gipa(instance, "vkCreatePipelineLayout"); + dt->vkCreateQueryPool = (PFN_vkCreateQueryPool)gipa(instance, "vkCreateQueryPool"); + dt->vkCreateRenderPass = (PFN_vkCreateRenderPass)gipa(instance, "vkCreateRenderPass"); + dt->vkCreateRenderPass2 = (PFN_vkCreateRenderPass2)gipa(instance, "vkCreateRenderPass2"); + if (!dt->vkCreateRenderPass2) dt->vkCreateRenderPass2 = (PFN_vkCreateRenderPass2)gipa(instance, "vkCreateRenderPass2KHR"); + dt->vkCreateSampler = (PFN_vkCreateSampler)gipa(instance, "vkCreateSampler"); + dt->vkCreateSamplerYcbcrConversion = (PFN_vkCreateSamplerYcbcrConversion)gipa(instance, "vkCreateSamplerYcbcrConversion"); + if (!dt->vkCreateSamplerYcbcrConversion) dt->vkCreateSamplerYcbcrConversion = (PFN_vkCreateSamplerYcbcrConversion)gipa(instance, "vkCreateSamplerYcbcrConversionKHR"); + dt->vkCreateSemaphore = (PFN_vkCreateSemaphore)gipa(instance, "vkCreateSemaphore"); + dt->vkCreateShaderModule = (PFN_vkCreateShaderModule)gipa(instance, "vkCreateShaderModule"); + dt->vkDestroyBuffer = (PFN_vkDestroyBuffer)gipa(instance, "vkDestroyBuffer"); + dt->vkDestroyBufferView = (PFN_vkDestroyBufferView)gipa(instance, "vkDestroyBufferView"); + dt->vkDestroyCommandPool = (PFN_vkDestroyCommandPool)gipa(instance, "vkDestroyCommandPool"); + dt->vkDestroyDescriptorPool = (PFN_vkDestroyDescriptorPool)gipa(instance, "vkDestroyDescriptorPool"); + dt->vkDestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout)gipa(instance, "vkDestroyDescriptorSetLayout"); + dt->vkDestroyDescriptorUpdateTemplate = (PFN_vkDestroyDescriptorUpdateTemplate)gipa(instance, "vkDestroyDescriptorUpdateTemplate"); + if (!dt->vkDestroyDescriptorUpdateTemplate) dt->vkDestroyDescriptorUpdateTemplate = (PFN_vkDestroyDescriptorUpdateTemplate)gipa(instance, "vkDestroyDescriptorUpdateTemplateKHR"); + dt->vkDestroyDevice = (PFN_vkDestroyDevice)gipa(instance, "vkDestroyDevice"); + dt->vkDestroyEvent = (PFN_vkDestroyEvent)gipa(instance, "vkDestroyEvent"); + dt->vkDestroyFence = (PFN_vkDestroyFence)gipa(instance, "vkDestroyFence"); + dt->vkDestroyFramebuffer = (PFN_vkDestroyFramebuffer)gipa(instance, "vkDestroyFramebuffer"); + dt->vkDestroyImage = (PFN_vkDestroyImage)gipa(instance, "vkDestroyImage"); + dt->vkDestroyImageView = (PFN_vkDestroyImageView)gipa(instance, "vkDestroyImageView"); + dt->vkDestroyInstance = (PFN_vkDestroyInstance)gipa(instance, "vkDestroyInstance"); + dt->vkDestroyPipeline = (PFN_vkDestroyPipeline)gipa(instance, "vkDestroyPipeline"); + dt->vkDestroyPipelineCache = (PFN_vkDestroyPipelineCache)gipa(instance, "vkDestroyPipelineCache"); + dt->vkDestroyPipelineLayout = (PFN_vkDestroyPipelineLayout)gipa(instance, "vkDestroyPipelineLayout"); + dt->vkDestroyQueryPool = (PFN_vkDestroyQueryPool)gipa(instance, "vkDestroyQueryPool"); + dt->vkDestroyRenderPass = (PFN_vkDestroyRenderPass)gipa(instance, "vkDestroyRenderPass"); + dt->vkDestroySampler = (PFN_vkDestroySampler)gipa(instance, "vkDestroySampler"); + dt->vkDestroySamplerYcbcrConversion = (PFN_vkDestroySamplerYcbcrConversion)gipa(instance, "vkDestroySamplerYcbcrConversion"); + if (!dt->vkDestroySamplerYcbcrConversion) dt->vkDestroySamplerYcbcrConversion = (PFN_vkDestroySamplerYcbcrConversion)gipa(instance, "vkDestroySamplerYcbcrConversionKHR"); + dt->vkDestroySemaphore = (PFN_vkDestroySemaphore)gipa(instance, "vkDestroySemaphore"); + dt->vkDestroyShaderModule = (PFN_vkDestroyShaderModule)gipa(instance, "vkDestroyShaderModule"); + dt->vkDeviceWaitIdle = (PFN_vkDeviceWaitIdle)gipa(instance, "vkDeviceWaitIdle"); + dt->vkEndCommandBuffer = (PFN_vkEndCommandBuffer)gipa(instance, "vkEndCommandBuffer"); + dt->vkEnumerateDeviceExtensionProperties = (PFN_vkEnumerateDeviceExtensionProperties)gipa(instance, "vkEnumerateDeviceExtensionProperties"); + dt->vkEnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)gipa(instance, "vkEnumerateInstanceExtensionProperties"); + dt->vkEnumerateInstanceLayerProperties = (PFN_vkEnumerateInstanceLayerProperties)gipa(instance, "vkEnumerateInstanceLayerProperties"); + dt->vkEnumerateInstanceVersion = (PFN_vkEnumerateInstanceVersion)gipa(instance, "vkEnumerateInstanceVersion"); + dt->vkEnumeratePhysicalDeviceGroups = (PFN_vkEnumeratePhysicalDeviceGroups)gipa(instance, "vkEnumeratePhysicalDeviceGroups"); + if (!dt->vkEnumeratePhysicalDeviceGroups) dt->vkEnumeratePhysicalDeviceGroups = (PFN_vkEnumeratePhysicalDeviceGroups)gipa(instance, "vkEnumeratePhysicalDeviceGroupsKHR"); + dt->vkEnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices)gipa(instance, "vkEnumeratePhysicalDevices"); + dt->vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)gipa(instance, "vkFlushMappedMemoryRanges"); + dt->vkFreeCommandBuffers = (PFN_vkFreeCommandBuffers)gipa(instance, "vkFreeCommandBuffers"); + dt->vkFreeDescriptorSets = (PFN_vkFreeDescriptorSets)gipa(instance, "vkFreeDescriptorSets"); + dt->vkFreeMemory = (PFN_vkFreeMemory)gipa(instance, "vkFreeMemory"); + dt->vkGetBufferDeviceAddress = (PFN_vkGetBufferDeviceAddress)gipa(instance, "vkGetBufferDeviceAddress"); + if (!dt->vkGetBufferDeviceAddress) dt->vkGetBufferDeviceAddress = (PFN_vkGetBufferDeviceAddress)gipa(instance, "vkGetBufferDeviceAddressEXT"); + if (!dt->vkGetBufferDeviceAddress) dt->vkGetBufferDeviceAddress = (PFN_vkGetBufferDeviceAddress)gipa(instance, "vkGetBufferDeviceAddressKHR"); + dt->vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)gipa(instance, "vkGetBufferMemoryRequirements"); + dt->vkGetBufferMemoryRequirements2 = (PFN_vkGetBufferMemoryRequirements2)gipa(instance, "vkGetBufferMemoryRequirements2"); + if (!dt->vkGetBufferMemoryRequirements2) dt->vkGetBufferMemoryRequirements2 = (PFN_vkGetBufferMemoryRequirements2)gipa(instance, "vkGetBufferMemoryRequirements2KHR"); + dt->vkGetBufferOpaqueCaptureAddress = (PFN_vkGetBufferOpaqueCaptureAddress)gipa(instance, "vkGetBufferOpaqueCaptureAddress"); + if (!dt->vkGetBufferOpaqueCaptureAddress) dt->vkGetBufferOpaqueCaptureAddress = (PFN_vkGetBufferOpaqueCaptureAddress)gipa(instance, "vkGetBufferOpaqueCaptureAddressKHR"); + dt->vkGetCalibratedTimestampsEXT = (PFN_vkGetCalibratedTimestampsEXT)gipa(instance, "vkGetCalibratedTimestampsEXT"); + dt->vkGetDescriptorSetLayoutSupport = (PFN_vkGetDescriptorSetLayoutSupport)gipa(instance, "vkGetDescriptorSetLayoutSupport"); + if (!dt->vkGetDescriptorSetLayoutSupport) dt->vkGetDescriptorSetLayoutSupport = (PFN_vkGetDescriptorSetLayoutSupport)gipa(instance, "vkGetDescriptorSetLayoutSupportKHR"); + dt->vkGetDeviceBufferMemoryRequirements = (PFN_vkGetDeviceBufferMemoryRequirements)gipa(instance, "vkGetDeviceBufferMemoryRequirements"); + if (!dt->vkGetDeviceBufferMemoryRequirements) dt->vkGetDeviceBufferMemoryRequirements = (PFN_vkGetDeviceBufferMemoryRequirements)gipa(instance, "vkGetDeviceBufferMemoryRequirementsKHR"); + dt->vkGetDeviceGroupPeerMemoryFeatures = (PFN_vkGetDeviceGroupPeerMemoryFeatures)gipa(instance, "vkGetDeviceGroupPeerMemoryFeatures"); + if (!dt->vkGetDeviceGroupPeerMemoryFeatures) dt->vkGetDeviceGroupPeerMemoryFeatures = (PFN_vkGetDeviceGroupPeerMemoryFeatures)gipa(instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR"); + dt->vkGetDeviceImageMemoryRequirements = (PFN_vkGetDeviceImageMemoryRequirements)gipa(instance, "vkGetDeviceImageMemoryRequirements"); + if (!dt->vkGetDeviceImageMemoryRequirements) dt->vkGetDeviceImageMemoryRequirements = (PFN_vkGetDeviceImageMemoryRequirements)gipa(instance, "vkGetDeviceImageMemoryRequirementsKHR"); + dt->vkGetDeviceImageSparseMemoryRequirements = (PFN_vkGetDeviceImageSparseMemoryRequirements)gipa(instance, "vkGetDeviceImageSparseMemoryRequirements"); + if (!dt->vkGetDeviceImageSparseMemoryRequirements) dt->vkGetDeviceImageSparseMemoryRequirements = (PFN_vkGetDeviceImageSparseMemoryRequirements)gipa(instance, "vkGetDeviceImageSparseMemoryRequirementsKHR"); + dt->vkGetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment)gipa(instance, "vkGetDeviceMemoryCommitment"); + dt->vkGetDeviceMemoryOpaqueCaptureAddress = (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)gipa(instance, "vkGetDeviceMemoryOpaqueCaptureAddress"); + if (!dt->vkGetDeviceMemoryOpaqueCaptureAddress) dt->vkGetDeviceMemoryOpaqueCaptureAddress = (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)gipa(instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"); + dt->vkGetDeviceQueue = (PFN_vkGetDeviceQueue)gipa(instance, "vkGetDeviceQueue"); + dt->vkGetDeviceQueue2 = (PFN_vkGetDeviceQueue2)gipa(instance, "vkGetDeviceQueue2"); + dt->vkGetEventStatus = (PFN_vkGetEventStatus)gipa(instance, "vkGetEventStatus"); + dt->vkGetFenceFdKHR = (PFN_vkGetFenceFdKHR)gipa(instance, "vkGetFenceFdKHR"); + dt->vkGetFenceStatus = (PFN_vkGetFenceStatus)gipa(instance, "vkGetFenceStatus"); + dt->vkGetImageDrmFormatModifierPropertiesEXT = (PFN_vkGetImageDrmFormatModifierPropertiesEXT)gipa(instance, "vkGetImageDrmFormatModifierPropertiesEXT"); + dt->vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)gipa(instance, "vkGetImageMemoryRequirements"); + dt->vkGetImageMemoryRequirements2 = (PFN_vkGetImageMemoryRequirements2)gipa(instance, "vkGetImageMemoryRequirements2"); + if (!dt->vkGetImageMemoryRequirements2) dt->vkGetImageMemoryRequirements2 = (PFN_vkGetImageMemoryRequirements2)gipa(instance, "vkGetImageMemoryRequirements2KHR"); + dt->vkGetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements)gipa(instance, "vkGetImageSparseMemoryRequirements"); + dt->vkGetImageSparseMemoryRequirements2 = (PFN_vkGetImageSparseMemoryRequirements2)gipa(instance, "vkGetImageSparseMemoryRequirements2"); + if (!dt->vkGetImageSparseMemoryRequirements2) dt->vkGetImageSparseMemoryRequirements2 = (PFN_vkGetImageSparseMemoryRequirements2)gipa(instance, "vkGetImageSparseMemoryRequirements2KHR"); + dt->vkGetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout)gipa(instance, "vkGetImageSubresourceLayout"); + dt->vkGetImageSubresourceLayout2EXT = (PFN_vkGetImageSubresourceLayout2EXT)gipa(instance, "vkGetImageSubresourceLayout2EXT"); + dt->vkGetMemoryFdKHR = (PFN_vkGetMemoryFdKHR)gipa(instance, "vkGetMemoryFdKHR"); + dt->vkGetMemoryFdPropertiesKHR = (PFN_vkGetMemoryFdPropertiesKHR)gipa(instance, "vkGetMemoryFdPropertiesKHR"); + dt->vkGetMemoryHostPointerPropertiesEXT = (PFN_vkGetMemoryHostPointerPropertiesEXT)gipa(instance, "vkGetMemoryHostPointerPropertiesEXT"); + dt->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = (PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)gipa(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"); + dt->vkGetPhysicalDeviceExternalBufferProperties = (PFN_vkGetPhysicalDeviceExternalBufferProperties)gipa(instance, "vkGetPhysicalDeviceExternalBufferProperties"); + if (!dt->vkGetPhysicalDeviceExternalBufferProperties) dt->vkGetPhysicalDeviceExternalBufferProperties = (PFN_vkGetPhysicalDeviceExternalBufferProperties)gipa(instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR"); + dt->vkGetPhysicalDeviceExternalFenceProperties = (PFN_vkGetPhysicalDeviceExternalFenceProperties)gipa(instance, "vkGetPhysicalDeviceExternalFenceProperties"); + if (!dt->vkGetPhysicalDeviceExternalFenceProperties) dt->vkGetPhysicalDeviceExternalFenceProperties = (PFN_vkGetPhysicalDeviceExternalFenceProperties)gipa(instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR"); + dt->vkGetPhysicalDeviceExternalSemaphoreProperties = (PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)gipa(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties"); + if (!dt->vkGetPhysicalDeviceExternalSemaphoreProperties) dt->vkGetPhysicalDeviceExternalSemaphoreProperties = (PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)gipa(instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"); + dt->vkGetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures)gipa(instance, "vkGetPhysicalDeviceFeatures"); + dt->vkGetPhysicalDeviceFeatures2 = (PFN_vkGetPhysicalDeviceFeatures2)gipa(instance, "vkGetPhysicalDeviceFeatures2"); + if (!dt->vkGetPhysicalDeviceFeatures2) dt->vkGetPhysicalDeviceFeatures2 = (PFN_vkGetPhysicalDeviceFeatures2)gipa(instance, "vkGetPhysicalDeviceFeatures2KHR"); + dt->vkGetPhysicalDeviceFormatProperties = (PFN_vkGetPhysicalDeviceFormatProperties)gipa(instance, "vkGetPhysicalDeviceFormatProperties"); + dt->vkGetPhysicalDeviceFormatProperties2 = (PFN_vkGetPhysicalDeviceFormatProperties2)gipa(instance, "vkGetPhysicalDeviceFormatProperties2"); + if (!dt->vkGetPhysicalDeviceFormatProperties2) dt->vkGetPhysicalDeviceFormatProperties2 = (PFN_vkGetPhysicalDeviceFormatProperties2)gipa(instance, "vkGetPhysicalDeviceFormatProperties2KHR"); + dt->vkGetPhysicalDeviceFragmentShadingRatesKHR = (PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)gipa(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR"); + dt->vkGetPhysicalDeviceImageFormatProperties = (PFN_vkGetPhysicalDeviceImageFormatProperties)gipa(instance, "vkGetPhysicalDeviceImageFormatProperties"); + dt->vkGetPhysicalDeviceImageFormatProperties2 = (PFN_vkGetPhysicalDeviceImageFormatProperties2)gipa(instance, "vkGetPhysicalDeviceImageFormatProperties2"); + if (!dt->vkGetPhysicalDeviceImageFormatProperties2) dt->vkGetPhysicalDeviceImageFormatProperties2 = (PFN_vkGetPhysicalDeviceImageFormatProperties2)gipa(instance, "vkGetPhysicalDeviceImageFormatProperties2KHR"); + dt->vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)gipa(instance, "vkGetPhysicalDeviceMemoryProperties"); + dt->vkGetPhysicalDeviceMemoryProperties2 = (PFN_vkGetPhysicalDeviceMemoryProperties2)gipa(instance, "vkGetPhysicalDeviceMemoryProperties2"); + if (!dt->vkGetPhysicalDeviceMemoryProperties2) dt->vkGetPhysicalDeviceMemoryProperties2 = (PFN_vkGetPhysicalDeviceMemoryProperties2)gipa(instance, "vkGetPhysicalDeviceMemoryProperties2KHR"); + dt->vkGetPhysicalDeviceMultisamplePropertiesEXT = (PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)gipa(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT"); + dt->vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)gipa(instance, "vkGetPhysicalDeviceProperties"); + dt->vkGetPhysicalDeviceProperties2 = (PFN_vkGetPhysicalDeviceProperties2)gipa(instance, "vkGetPhysicalDeviceProperties2"); + if (!dt->vkGetPhysicalDeviceProperties2) dt->vkGetPhysicalDeviceProperties2 = (PFN_vkGetPhysicalDeviceProperties2)gipa(instance, "vkGetPhysicalDeviceProperties2KHR"); + dt->vkGetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties)gipa(instance, "vkGetPhysicalDeviceQueueFamilyProperties"); + dt->vkGetPhysicalDeviceQueueFamilyProperties2 = (PFN_vkGetPhysicalDeviceQueueFamilyProperties2)gipa(instance, "vkGetPhysicalDeviceQueueFamilyProperties2"); + if (!dt->vkGetPhysicalDeviceQueueFamilyProperties2) dt->vkGetPhysicalDeviceQueueFamilyProperties2 = (PFN_vkGetPhysicalDeviceQueueFamilyProperties2)gipa(instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"); + dt->vkGetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties)gipa(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"); + dt->vkGetPhysicalDeviceSparseImageFormatProperties2 = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)gipa(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2"); + if (!dt->vkGetPhysicalDeviceSparseImageFormatProperties2) dt->vkGetPhysicalDeviceSparseImageFormatProperties2 = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)gipa(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"); + dt->vkGetPhysicalDeviceToolProperties = (PFN_vkGetPhysicalDeviceToolProperties)gipa(instance, "vkGetPhysicalDeviceToolProperties"); + if (!dt->vkGetPhysicalDeviceToolProperties) dt->vkGetPhysicalDeviceToolProperties = (PFN_vkGetPhysicalDeviceToolProperties)gipa(instance, "vkGetPhysicalDeviceToolPropertiesEXT"); + dt->vkGetPipelineCacheData = (PFN_vkGetPipelineCacheData)gipa(instance, "vkGetPipelineCacheData"); + dt->vkGetQueryPoolResults = (PFN_vkGetQueryPoolResults)gipa(instance, "vkGetQueryPoolResults"); + dt->vkGetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity)gipa(instance, "vkGetRenderAreaGranularity"); + dt->vkGetSemaphoreCounterValue = (PFN_vkGetSemaphoreCounterValue)gipa(instance, "vkGetSemaphoreCounterValue"); + if (!dt->vkGetSemaphoreCounterValue) dt->vkGetSemaphoreCounterValue = (PFN_vkGetSemaphoreCounterValue)gipa(instance, "vkGetSemaphoreCounterValueKHR"); + dt->vkGetSemaphoreFdKHR = (PFN_vkGetSemaphoreFdKHR)gipa(instance, "vkGetSemaphoreFdKHR"); + dt->vkGetShaderModuleCreateInfoIdentifierEXT = (PFN_vkGetShaderModuleCreateInfoIdentifierEXT)gipa(instance, "vkGetShaderModuleCreateInfoIdentifierEXT"); + dt->vkGetShaderModuleIdentifierEXT = (PFN_vkGetShaderModuleIdentifierEXT)gipa(instance, "vkGetShaderModuleIdentifierEXT"); + dt->vkImportFenceFdKHR = (PFN_vkImportFenceFdKHR)gipa(instance, "vkImportFenceFdKHR"); + dt->vkImportSemaphoreFdKHR = (PFN_vkImportSemaphoreFdKHR)gipa(instance, "vkImportSemaphoreFdKHR"); + dt->vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)gipa(instance, "vkInvalidateMappedMemoryRanges"); + dt->vkMapMemory = (PFN_vkMapMemory)gipa(instance, "vkMapMemory"); + dt->vkMergePipelineCaches = (PFN_vkMergePipelineCaches)gipa(instance, "vkMergePipelineCaches"); + dt->vkQueueBindSparse = (PFN_vkQueueBindSparse)gipa(instance, "vkQueueBindSparse"); + dt->vkQueueSubmit = (PFN_vkQueueSubmit)gipa(instance, "vkQueueSubmit"); + dt->vkQueueSubmit2 = (PFN_vkQueueSubmit2)gipa(instance, "vkQueueSubmit2"); + if (!dt->vkQueueSubmit2) dt->vkQueueSubmit2 = (PFN_vkQueueSubmit2)gipa(instance, "vkQueueSubmit2KHR"); + dt->vkQueueWaitIdle = (PFN_vkQueueWaitIdle)gipa(instance, "vkQueueWaitIdle"); + dt->vkResetCommandBuffer = (PFN_vkResetCommandBuffer)gipa(instance, "vkResetCommandBuffer"); + dt->vkResetCommandPool = (PFN_vkResetCommandPool)gipa(instance, "vkResetCommandPool"); + dt->vkResetDescriptorPool = (PFN_vkResetDescriptorPool)gipa(instance, "vkResetDescriptorPool"); + dt->vkResetEvent = (PFN_vkResetEvent)gipa(instance, "vkResetEvent"); + dt->vkResetFences = (PFN_vkResetFences)gipa(instance, "vkResetFences"); + dt->vkResetQueryPool = (PFN_vkResetQueryPool)gipa(instance, "vkResetQueryPool"); + if (!dt->vkResetQueryPool) dt->vkResetQueryPool = (PFN_vkResetQueryPool)gipa(instance, "vkResetQueryPoolEXT"); + dt->vkSetDeviceMemoryPriorityEXT = (PFN_vkSetDeviceMemoryPriorityEXT)gipa(instance, "vkSetDeviceMemoryPriorityEXT"); + dt->vkSetEvent = (PFN_vkSetEvent)gipa(instance, "vkSetEvent"); + dt->vkSignalSemaphore = (PFN_vkSignalSemaphore)gipa(instance, "vkSignalSemaphore"); + if (!dt->vkSignalSemaphore) dt->vkSignalSemaphore = (PFN_vkSignalSemaphore)gipa(instance, "vkSignalSemaphoreKHR"); + dt->vkTrimCommandPool = (PFN_vkTrimCommandPool)gipa(instance, "vkTrimCommandPool"); + if (!dt->vkTrimCommandPool) dt->vkTrimCommandPool = (PFN_vkTrimCommandPool)gipa(instance, "vkTrimCommandPoolKHR"); + dt->vkUnmapMemory = (PFN_vkUnmapMemory)gipa(instance, "vkUnmapMemory"); + dt->vkUpdateDescriptorSetWithTemplate = (PFN_vkUpdateDescriptorSetWithTemplate)gipa(instance, "vkUpdateDescriptorSetWithTemplate"); + if (!dt->vkUpdateDescriptorSetWithTemplate) dt->vkUpdateDescriptorSetWithTemplate = (PFN_vkUpdateDescriptorSetWithTemplate)gipa(instance, "vkUpdateDescriptorSetWithTemplateKHR"); + dt->vkUpdateDescriptorSets = (PFN_vkUpdateDescriptorSets)gipa(instance, "vkUpdateDescriptorSets"); + dt->vkWaitForFences = (PFN_vkWaitForFences)gipa(instance, "vkWaitForFences"); + dt->vkWaitSemaphores = (PFN_vkWaitSemaphores)gipa(instance, "vkWaitSemaphores"); + if (!dt->vkWaitSemaphores) dt->vkWaitSemaphores = (PFN_vkWaitSemaphores)gipa(instance, "vkWaitSemaphoresKHR"); +} + +void vkb_dispatch_load_device(vkb_dispatch *dt, PFN_vkGetDeviceProcAddr gdpa, VkDevice device) +{ + { + PFN_vkAllocateCommandBuffers f_ = (PFN_vkAllocateCommandBuffers)gdpa(device, "vkAllocateCommandBuffers"); + if (f_) dt->vkAllocateCommandBuffers = f_; + } + { + PFN_vkAllocateDescriptorSets f_ = (PFN_vkAllocateDescriptorSets)gdpa(device, "vkAllocateDescriptorSets"); + if (f_) dt->vkAllocateDescriptorSets = f_; + } + { + PFN_vkAllocateMemory f_ = (PFN_vkAllocateMemory)gdpa(device, "vkAllocateMemory"); + if (f_) dt->vkAllocateMemory = f_; + } + { + PFN_vkBeginCommandBuffer f_ = (PFN_vkBeginCommandBuffer)gdpa(device, "vkBeginCommandBuffer"); + if (f_) dt->vkBeginCommandBuffer = f_; + } + { + PFN_vkBindBufferMemory f_ = (PFN_vkBindBufferMemory)gdpa(device, "vkBindBufferMemory"); + if (f_) dt->vkBindBufferMemory = f_; + } + { + PFN_vkBindBufferMemory2 f_ = (PFN_vkBindBufferMemory2)gdpa(device, "vkBindBufferMemory2"); + if (!f_) f_ = (PFN_vkBindBufferMemory2)gdpa(device, "vkBindBufferMemory2KHR"); + if (f_) dt->vkBindBufferMemory2 = f_; + } + { + PFN_vkBindImageMemory f_ = (PFN_vkBindImageMemory)gdpa(device, "vkBindImageMemory"); + if (f_) dt->vkBindImageMemory = f_; + } + { + PFN_vkBindImageMemory2 f_ = (PFN_vkBindImageMemory2)gdpa(device, "vkBindImageMemory2"); + if (!f_) f_ = (PFN_vkBindImageMemory2)gdpa(device, "vkBindImageMemory2KHR"); + if (f_) dt->vkBindImageMemory2 = f_; + } + { + PFN_vkCmdBeginConditionalRenderingEXT f_ = (PFN_vkCmdBeginConditionalRenderingEXT)gdpa(device, "vkCmdBeginConditionalRenderingEXT"); + if (f_) dt->vkCmdBeginConditionalRenderingEXT = f_; + } + { + PFN_vkCmdBeginQuery f_ = (PFN_vkCmdBeginQuery)gdpa(device, "vkCmdBeginQuery"); + if (f_) dt->vkCmdBeginQuery = f_; + } + { + PFN_vkCmdBeginQueryIndexedEXT f_ = (PFN_vkCmdBeginQueryIndexedEXT)gdpa(device, "vkCmdBeginQueryIndexedEXT"); + if (f_) dt->vkCmdBeginQueryIndexedEXT = f_; + } + { + PFN_vkCmdBeginRenderPass f_ = (PFN_vkCmdBeginRenderPass)gdpa(device, "vkCmdBeginRenderPass"); + if (f_) dt->vkCmdBeginRenderPass = f_; + } + { + PFN_vkCmdBeginRenderPass2 f_ = (PFN_vkCmdBeginRenderPass2)gdpa(device, "vkCmdBeginRenderPass2"); + if (!f_) f_ = (PFN_vkCmdBeginRenderPass2)gdpa(device, "vkCmdBeginRenderPass2KHR"); + if (f_) dt->vkCmdBeginRenderPass2 = f_; + } + { + PFN_vkCmdBeginRendering f_ = (PFN_vkCmdBeginRendering)gdpa(device, "vkCmdBeginRendering"); + if (!f_) f_ = (PFN_vkCmdBeginRendering)gdpa(device, "vkCmdBeginRenderingKHR"); + if (f_) dt->vkCmdBeginRendering = f_; + } + { + PFN_vkCmdBeginTransformFeedbackEXT f_ = (PFN_vkCmdBeginTransformFeedbackEXT)gdpa(device, "vkCmdBeginTransformFeedbackEXT"); + if (f_) dt->vkCmdBeginTransformFeedbackEXT = f_; + } + { + PFN_vkCmdBindDescriptorSets f_ = (PFN_vkCmdBindDescriptorSets)gdpa(device, "vkCmdBindDescriptorSets"); + if (f_) dt->vkCmdBindDescriptorSets = f_; + } + { + PFN_vkCmdBindIndexBuffer f_ = (PFN_vkCmdBindIndexBuffer)gdpa(device, "vkCmdBindIndexBuffer"); + if (f_) dt->vkCmdBindIndexBuffer = f_; + } + { + PFN_vkCmdBindPipeline f_ = (PFN_vkCmdBindPipeline)gdpa(device, "vkCmdBindPipeline"); + if (f_) dt->vkCmdBindPipeline = f_; + } + { + PFN_vkCmdBindTransformFeedbackBuffersEXT f_ = (PFN_vkCmdBindTransformFeedbackBuffersEXT)gdpa(device, "vkCmdBindTransformFeedbackBuffersEXT"); + if (f_) dt->vkCmdBindTransformFeedbackBuffersEXT = f_; + } + { + PFN_vkCmdBindVertexBuffers f_ = (PFN_vkCmdBindVertexBuffers)gdpa(device, "vkCmdBindVertexBuffers"); + if (f_) dt->vkCmdBindVertexBuffers = f_; + } + { + PFN_vkCmdBindVertexBuffers2 f_ = (PFN_vkCmdBindVertexBuffers2)gdpa(device, "vkCmdBindVertexBuffers2"); + if (!f_) f_ = (PFN_vkCmdBindVertexBuffers2)gdpa(device, "vkCmdBindVertexBuffers2EXT"); + if (f_) dt->vkCmdBindVertexBuffers2 = f_; + } + { + PFN_vkCmdBlitImage f_ = (PFN_vkCmdBlitImage)gdpa(device, "vkCmdBlitImage"); + if (f_) dt->vkCmdBlitImage = f_; + } + { + PFN_vkCmdBlitImage2 f_ = (PFN_vkCmdBlitImage2)gdpa(device, "vkCmdBlitImage2"); + if (!f_) f_ = (PFN_vkCmdBlitImage2)gdpa(device, "vkCmdBlitImage2KHR"); + if (f_) dt->vkCmdBlitImage2 = f_; + } + { + PFN_vkCmdClearAttachments f_ = (PFN_vkCmdClearAttachments)gdpa(device, "vkCmdClearAttachments"); + if (f_) dt->vkCmdClearAttachments = f_; + } + { + PFN_vkCmdClearColorImage f_ = (PFN_vkCmdClearColorImage)gdpa(device, "vkCmdClearColorImage"); + if (f_) dt->vkCmdClearColorImage = f_; + } + { + PFN_vkCmdClearDepthStencilImage f_ = (PFN_vkCmdClearDepthStencilImage)gdpa(device, "vkCmdClearDepthStencilImage"); + if (f_) dt->vkCmdClearDepthStencilImage = f_; + } + { + PFN_vkCmdCopyBuffer f_ = (PFN_vkCmdCopyBuffer)gdpa(device, "vkCmdCopyBuffer"); + if (f_) dt->vkCmdCopyBuffer = f_; + } + { + PFN_vkCmdCopyBuffer2 f_ = (PFN_vkCmdCopyBuffer2)gdpa(device, "vkCmdCopyBuffer2"); + if (!f_) f_ = (PFN_vkCmdCopyBuffer2)gdpa(device, "vkCmdCopyBuffer2KHR"); + if (f_) dt->vkCmdCopyBuffer2 = f_; + } + { + PFN_vkCmdCopyBufferToImage f_ = (PFN_vkCmdCopyBufferToImage)gdpa(device, "vkCmdCopyBufferToImage"); + if (f_) dt->vkCmdCopyBufferToImage = f_; + } + { + PFN_vkCmdCopyBufferToImage2 f_ = (PFN_vkCmdCopyBufferToImage2)gdpa(device, "vkCmdCopyBufferToImage2"); + if (!f_) f_ = (PFN_vkCmdCopyBufferToImage2)gdpa(device, "vkCmdCopyBufferToImage2KHR"); + if (f_) dt->vkCmdCopyBufferToImage2 = f_; + } + { + PFN_vkCmdCopyImage f_ = (PFN_vkCmdCopyImage)gdpa(device, "vkCmdCopyImage"); + if (f_) dt->vkCmdCopyImage = f_; + } + { + PFN_vkCmdCopyImage2 f_ = (PFN_vkCmdCopyImage2)gdpa(device, "vkCmdCopyImage2"); + if (!f_) f_ = (PFN_vkCmdCopyImage2)gdpa(device, "vkCmdCopyImage2KHR"); + if (f_) dt->vkCmdCopyImage2 = f_; + } + { + PFN_vkCmdCopyImageToBuffer f_ = (PFN_vkCmdCopyImageToBuffer)gdpa(device, "vkCmdCopyImageToBuffer"); + if (f_) dt->vkCmdCopyImageToBuffer = f_; + } + { + PFN_vkCmdCopyImageToBuffer2 f_ = (PFN_vkCmdCopyImageToBuffer2)gdpa(device, "vkCmdCopyImageToBuffer2"); + if (!f_) f_ = (PFN_vkCmdCopyImageToBuffer2)gdpa(device, "vkCmdCopyImageToBuffer2KHR"); + if (f_) dt->vkCmdCopyImageToBuffer2 = f_; + } + { + PFN_vkCmdCopyQueryPoolResults f_ = (PFN_vkCmdCopyQueryPoolResults)gdpa(device, "vkCmdCopyQueryPoolResults"); + if (f_) dt->vkCmdCopyQueryPoolResults = f_; + } + { + PFN_vkCmdDispatch f_ = (PFN_vkCmdDispatch)gdpa(device, "vkCmdDispatch"); + if (f_) dt->vkCmdDispatch = f_; + } + { + PFN_vkCmdDispatchBase f_ = (PFN_vkCmdDispatchBase)gdpa(device, "vkCmdDispatchBase"); + if (!f_) f_ = (PFN_vkCmdDispatchBase)gdpa(device, "vkCmdDispatchBaseKHR"); + if (f_) dt->vkCmdDispatchBase = f_; + } + { + PFN_vkCmdDispatchIndirect f_ = (PFN_vkCmdDispatchIndirect)gdpa(device, "vkCmdDispatchIndirect"); + if (f_) dt->vkCmdDispatchIndirect = f_; + } + { + PFN_vkCmdDraw f_ = (PFN_vkCmdDraw)gdpa(device, "vkCmdDraw"); + if (f_) dt->vkCmdDraw = f_; + } + { + PFN_vkCmdDrawIndexed f_ = (PFN_vkCmdDrawIndexed)gdpa(device, "vkCmdDrawIndexed"); + if (f_) dt->vkCmdDrawIndexed = f_; + } + { + PFN_vkCmdDrawIndexedIndirect f_ = (PFN_vkCmdDrawIndexedIndirect)gdpa(device, "vkCmdDrawIndexedIndirect"); + if (f_) dt->vkCmdDrawIndexedIndirect = f_; + } + { + PFN_vkCmdDrawIndexedIndirectCount f_ = (PFN_vkCmdDrawIndexedIndirectCount)gdpa(device, "vkCmdDrawIndexedIndirectCount"); + if (!f_) f_ = (PFN_vkCmdDrawIndexedIndirectCount)gdpa(device, "vkCmdDrawIndexedIndirectCountAMD"); + if (!f_) f_ = (PFN_vkCmdDrawIndexedIndirectCount)gdpa(device, "vkCmdDrawIndexedIndirectCountKHR"); + if (f_) dt->vkCmdDrawIndexedIndirectCount = f_; + } + { + PFN_vkCmdDrawIndirect f_ = (PFN_vkCmdDrawIndirect)gdpa(device, "vkCmdDrawIndirect"); + if (f_) dt->vkCmdDrawIndirect = f_; + } + { + PFN_vkCmdDrawIndirectByteCountEXT f_ = (PFN_vkCmdDrawIndirectByteCountEXT)gdpa(device, "vkCmdDrawIndirectByteCountEXT"); + if (f_) dt->vkCmdDrawIndirectByteCountEXT = f_; + } + { + PFN_vkCmdDrawIndirectCount f_ = (PFN_vkCmdDrawIndirectCount)gdpa(device, "vkCmdDrawIndirectCount"); + if (!f_) f_ = (PFN_vkCmdDrawIndirectCount)gdpa(device, "vkCmdDrawIndirectCountAMD"); + if (!f_) f_ = (PFN_vkCmdDrawIndirectCount)gdpa(device, "vkCmdDrawIndirectCountKHR"); + if (f_) dt->vkCmdDrawIndirectCount = f_; + } + { + PFN_vkCmdDrawMultiEXT f_ = (PFN_vkCmdDrawMultiEXT)gdpa(device, "vkCmdDrawMultiEXT"); + if (f_) dt->vkCmdDrawMultiEXT = f_; + } + { + PFN_vkCmdDrawMultiIndexedEXT f_ = (PFN_vkCmdDrawMultiIndexedEXT)gdpa(device, "vkCmdDrawMultiIndexedEXT"); + if (f_) dt->vkCmdDrawMultiIndexedEXT = f_; + } + { + PFN_vkCmdEndConditionalRenderingEXT f_ = (PFN_vkCmdEndConditionalRenderingEXT)gdpa(device, "vkCmdEndConditionalRenderingEXT"); + if (f_) dt->vkCmdEndConditionalRenderingEXT = f_; + } + { + PFN_vkCmdEndQuery f_ = (PFN_vkCmdEndQuery)gdpa(device, "vkCmdEndQuery"); + if (f_) dt->vkCmdEndQuery = f_; + } + { + PFN_vkCmdEndQueryIndexedEXT f_ = (PFN_vkCmdEndQueryIndexedEXT)gdpa(device, "vkCmdEndQueryIndexedEXT"); + if (f_) dt->vkCmdEndQueryIndexedEXT = f_; + } + { + PFN_vkCmdEndRenderPass f_ = (PFN_vkCmdEndRenderPass)gdpa(device, "vkCmdEndRenderPass"); + if (f_) dt->vkCmdEndRenderPass = f_; + } + { + PFN_vkCmdEndRenderPass2 f_ = (PFN_vkCmdEndRenderPass2)gdpa(device, "vkCmdEndRenderPass2"); + if (!f_) f_ = (PFN_vkCmdEndRenderPass2)gdpa(device, "vkCmdEndRenderPass2KHR"); + if (f_) dt->vkCmdEndRenderPass2 = f_; + } + { + PFN_vkCmdEndRendering f_ = (PFN_vkCmdEndRendering)gdpa(device, "vkCmdEndRendering"); + if (!f_) f_ = (PFN_vkCmdEndRendering)gdpa(device, "vkCmdEndRenderingKHR"); + if (f_) dt->vkCmdEndRendering = f_; + } + { + PFN_vkCmdEndTransformFeedbackEXT f_ = (PFN_vkCmdEndTransformFeedbackEXT)gdpa(device, "vkCmdEndTransformFeedbackEXT"); + if (f_) dt->vkCmdEndTransformFeedbackEXT = f_; + } + { + PFN_vkCmdExecuteCommands f_ = (PFN_vkCmdExecuteCommands)gdpa(device, "vkCmdExecuteCommands"); + if (f_) dt->vkCmdExecuteCommands = f_; + } + { + PFN_vkCmdFillBuffer f_ = (PFN_vkCmdFillBuffer)gdpa(device, "vkCmdFillBuffer"); + if (f_) dt->vkCmdFillBuffer = f_; + } + { + PFN_vkCmdNextSubpass f_ = (PFN_vkCmdNextSubpass)gdpa(device, "vkCmdNextSubpass"); + if (f_) dt->vkCmdNextSubpass = f_; + } + { + PFN_vkCmdNextSubpass2 f_ = (PFN_vkCmdNextSubpass2)gdpa(device, "vkCmdNextSubpass2"); + if (!f_) f_ = (PFN_vkCmdNextSubpass2)gdpa(device, "vkCmdNextSubpass2KHR"); + if (f_) dt->vkCmdNextSubpass2 = f_; + } + { + PFN_vkCmdPipelineBarrier f_ = (PFN_vkCmdPipelineBarrier)gdpa(device, "vkCmdPipelineBarrier"); + if (f_) dt->vkCmdPipelineBarrier = f_; + } + { + PFN_vkCmdPipelineBarrier2 f_ = (PFN_vkCmdPipelineBarrier2)gdpa(device, "vkCmdPipelineBarrier2"); + if (!f_) f_ = (PFN_vkCmdPipelineBarrier2)gdpa(device, "vkCmdPipelineBarrier2KHR"); + if (f_) dt->vkCmdPipelineBarrier2 = f_; + } + { + PFN_vkCmdPushConstants f_ = (PFN_vkCmdPushConstants)gdpa(device, "vkCmdPushConstants"); + if (f_) dt->vkCmdPushConstants = f_; + } + { + PFN_vkCmdPushDescriptorSetKHR f_ = (PFN_vkCmdPushDescriptorSetKHR)gdpa(device, "vkCmdPushDescriptorSetKHR"); + if (f_) dt->vkCmdPushDescriptorSetKHR = f_; + } + { + PFN_vkCmdPushDescriptorSetWithTemplateKHR f_ = (PFN_vkCmdPushDescriptorSetWithTemplateKHR)gdpa(device, "vkCmdPushDescriptorSetWithTemplateKHR"); + if (f_) dt->vkCmdPushDescriptorSetWithTemplateKHR = f_; + } + { + PFN_vkCmdResetEvent f_ = (PFN_vkCmdResetEvent)gdpa(device, "vkCmdResetEvent"); + if (f_) dt->vkCmdResetEvent = f_; + } + { + PFN_vkCmdResetEvent2 f_ = (PFN_vkCmdResetEvent2)gdpa(device, "vkCmdResetEvent2"); + if (!f_) f_ = (PFN_vkCmdResetEvent2)gdpa(device, "vkCmdResetEvent2KHR"); + if (f_) dt->vkCmdResetEvent2 = f_; + } + { + PFN_vkCmdResetQueryPool f_ = (PFN_vkCmdResetQueryPool)gdpa(device, "vkCmdResetQueryPool"); + if (f_) dt->vkCmdResetQueryPool = f_; + } + { + PFN_vkCmdResolveImage f_ = (PFN_vkCmdResolveImage)gdpa(device, "vkCmdResolveImage"); + if (f_) dt->vkCmdResolveImage = f_; + } + { + PFN_vkCmdResolveImage2 f_ = (PFN_vkCmdResolveImage2)gdpa(device, "vkCmdResolveImage2"); + if (!f_) f_ = (PFN_vkCmdResolveImage2)gdpa(device, "vkCmdResolveImage2KHR"); + if (f_) dt->vkCmdResolveImage2 = f_; + } + { + PFN_vkCmdSetAlphaToCoverageEnableEXT f_ = (PFN_vkCmdSetAlphaToCoverageEnableEXT)gdpa(device, "vkCmdSetAlphaToCoverageEnableEXT"); + if (f_) dt->vkCmdSetAlphaToCoverageEnableEXT = f_; + } + { + PFN_vkCmdSetAlphaToOneEnableEXT f_ = (PFN_vkCmdSetAlphaToOneEnableEXT)gdpa(device, "vkCmdSetAlphaToOneEnableEXT"); + if (f_) dt->vkCmdSetAlphaToOneEnableEXT = f_; + } + { + PFN_vkCmdSetBlendConstants f_ = (PFN_vkCmdSetBlendConstants)gdpa(device, "vkCmdSetBlendConstants"); + if (f_) dt->vkCmdSetBlendConstants = f_; + } + { + PFN_vkCmdSetColorBlendAdvancedEXT f_ = (PFN_vkCmdSetColorBlendAdvancedEXT)gdpa(device, "vkCmdSetColorBlendAdvancedEXT"); + if (f_) dt->vkCmdSetColorBlendAdvancedEXT = f_; + } + { + PFN_vkCmdSetColorBlendEnableEXT f_ = (PFN_vkCmdSetColorBlendEnableEXT)gdpa(device, "vkCmdSetColorBlendEnableEXT"); + if (f_) dt->vkCmdSetColorBlendEnableEXT = f_; + } + { + PFN_vkCmdSetColorBlendEquationEXT f_ = (PFN_vkCmdSetColorBlendEquationEXT)gdpa(device, "vkCmdSetColorBlendEquationEXT"); + if (f_) dt->vkCmdSetColorBlendEquationEXT = f_; + } + { + PFN_vkCmdSetColorWriteEnableEXT f_ = (PFN_vkCmdSetColorWriteEnableEXT)gdpa(device, "vkCmdSetColorWriteEnableEXT"); + if (f_) dt->vkCmdSetColorWriteEnableEXT = f_; + } + { + PFN_vkCmdSetColorWriteMaskEXT f_ = (PFN_vkCmdSetColorWriteMaskEXT)gdpa(device, "vkCmdSetColorWriteMaskEXT"); + if (f_) dt->vkCmdSetColorWriteMaskEXT = f_; + } + { + PFN_vkCmdSetConservativeRasterizationModeEXT f_ = (PFN_vkCmdSetConservativeRasterizationModeEXT)gdpa(device, "vkCmdSetConservativeRasterizationModeEXT"); + if (f_) dt->vkCmdSetConservativeRasterizationModeEXT = f_; + } + { + PFN_vkCmdSetCoverageModulationModeNV f_ = (PFN_vkCmdSetCoverageModulationModeNV)gdpa(device, "vkCmdSetCoverageModulationModeNV"); + if (f_) dt->vkCmdSetCoverageModulationModeNV = f_; + } + { + PFN_vkCmdSetCoverageModulationTableEnableNV f_ = (PFN_vkCmdSetCoverageModulationTableEnableNV)gdpa(device, "vkCmdSetCoverageModulationTableEnableNV"); + if (f_) dt->vkCmdSetCoverageModulationTableEnableNV = f_; + } + { + PFN_vkCmdSetCoverageModulationTableNV f_ = (PFN_vkCmdSetCoverageModulationTableNV)gdpa(device, "vkCmdSetCoverageModulationTableNV"); + if (f_) dt->vkCmdSetCoverageModulationTableNV = f_; + } + { + PFN_vkCmdSetCoverageReductionModeNV f_ = (PFN_vkCmdSetCoverageReductionModeNV)gdpa(device, "vkCmdSetCoverageReductionModeNV"); + if (f_) dt->vkCmdSetCoverageReductionModeNV = f_; + } + { + PFN_vkCmdSetCoverageToColorEnableNV f_ = (PFN_vkCmdSetCoverageToColorEnableNV)gdpa(device, "vkCmdSetCoverageToColorEnableNV"); + if (f_) dt->vkCmdSetCoverageToColorEnableNV = f_; + } + { + PFN_vkCmdSetCoverageToColorLocationNV f_ = (PFN_vkCmdSetCoverageToColorLocationNV)gdpa(device, "vkCmdSetCoverageToColorLocationNV"); + if (f_) dt->vkCmdSetCoverageToColorLocationNV = f_; + } + { + PFN_vkCmdSetCullMode f_ = (PFN_vkCmdSetCullMode)gdpa(device, "vkCmdSetCullMode"); + if (!f_) f_ = (PFN_vkCmdSetCullMode)gdpa(device, "vkCmdSetCullModeEXT"); + if (f_) dt->vkCmdSetCullMode = f_; + } + { + PFN_vkCmdSetDepthBias f_ = (PFN_vkCmdSetDepthBias)gdpa(device, "vkCmdSetDepthBias"); + if (f_) dt->vkCmdSetDepthBias = f_; + } + { + PFN_vkCmdSetDepthBiasEnable f_ = (PFN_vkCmdSetDepthBiasEnable)gdpa(device, "vkCmdSetDepthBiasEnable"); + if (!f_) f_ = (PFN_vkCmdSetDepthBiasEnable)gdpa(device, "vkCmdSetDepthBiasEnableEXT"); + if (f_) dt->vkCmdSetDepthBiasEnable = f_; + } + { + PFN_vkCmdSetDepthBounds f_ = (PFN_vkCmdSetDepthBounds)gdpa(device, "vkCmdSetDepthBounds"); + if (f_) dt->vkCmdSetDepthBounds = f_; + } + { + PFN_vkCmdSetDepthBoundsTestEnable f_ = (PFN_vkCmdSetDepthBoundsTestEnable)gdpa(device, "vkCmdSetDepthBoundsTestEnable"); + if (!f_) f_ = (PFN_vkCmdSetDepthBoundsTestEnable)gdpa(device, "vkCmdSetDepthBoundsTestEnableEXT"); + if (f_) dt->vkCmdSetDepthBoundsTestEnable = f_; + } + { + PFN_vkCmdSetDepthClampEnableEXT f_ = (PFN_vkCmdSetDepthClampEnableEXT)gdpa(device, "vkCmdSetDepthClampEnableEXT"); + if (f_) dt->vkCmdSetDepthClampEnableEXT = f_; + } + { + PFN_vkCmdSetDepthClipEnableEXT f_ = (PFN_vkCmdSetDepthClipEnableEXT)gdpa(device, "vkCmdSetDepthClipEnableEXT"); + if (f_) dt->vkCmdSetDepthClipEnableEXT = f_; + } + { + PFN_vkCmdSetDepthClipNegativeOneToOneEXT f_ = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)gdpa(device, "vkCmdSetDepthClipNegativeOneToOneEXT"); + if (f_) dt->vkCmdSetDepthClipNegativeOneToOneEXT = f_; + } + { + PFN_vkCmdSetDepthCompareOp f_ = (PFN_vkCmdSetDepthCompareOp)gdpa(device, "vkCmdSetDepthCompareOp"); + if (!f_) f_ = (PFN_vkCmdSetDepthCompareOp)gdpa(device, "vkCmdSetDepthCompareOpEXT"); + if (f_) dt->vkCmdSetDepthCompareOp = f_; + } + { + PFN_vkCmdSetDepthTestEnable f_ = (PFN_vkCmdSetDepthTestEnable)gdpa(device, "vkCmdSetDepthTestEnable"); + if (!f_) f_ = (PFN_vkCmdSetDepthTestEnable)gdpa(device, "vkCmdSetDepthTestEnableEXT"); + if (f_) dt->vkCmdSetDepthTestEnable = f_; + } + { + PFN_vkCmdSetDepthWriteEnable f_ = (PFN_vkCmdSetDepthWriteEnable)gdpa(device, "vkCmdSetDepthWriteEnable"); + if (!f_) f_ = (PFN_vkCmdSetDepthWriteEnable)gdpa(device, "vkCmdSetDepthWriteEnableEXT"); + if (f_) dt->vkCmdSetDepthWriteEnable = f_; + } + { + PFN_vkCmdSetDeviceMask f_ = (PFN_vkCmdSetDeviceMask)gdpa(device, "vkCmdSetDeviceMask"); + if (!f_) f_ = (PFN_vkCmdSetDeviceMask)gdpa(device, "vkCmdSetDeviceMaskKHR"); + if (f_) dt->vkCmdSetDeviceMask = f_; + } + { + PFN_vkCmdSetDiscardRectangleEXT f_ = (PFN_vkCmdSetDiscardRectangleEXT)gdpa(device, "vkCmdSetDiscardRectangleEXT"); + if (f_) dt->vkCmdSetDiscardRectangleEXT = f_; + } + { + PFN_vkCmdSetDiscardRectangleEnableEXT f_ = (PFN_vkCmdSetDiscardRectangleEnableEXT)gdpa(device, "vkCmdSetDiscardRectangleEnableEXT"); + if (f_) dt->vkCmdSetDiscardRectangleEnableEXT = f_; + } + { + PFN_vkCmdSetDiscardRectangleModeEXT f_ = (PFN_vkCmdSetDiscardRectangleModeEXT)gdpa(device, "vkCmdSetDiscardRectangleModeEXT"); + if (f_) dt->vkCmdSetDiscardRectangleModeEXT = f_; + } + { + PFN_vkCmdSetEvent f_ = (PFN_vkCmdSetEvent)gdpa(device, "vkCmdSetEvent"); + if (f_) dt->vkCmdSetEvent = f_; + } + { + PFN_vkCmdSetEvent2 f_ = (PFN_vkCmdSetEvent2)gdpa(device, "vkCmdSetEvent2"); + if (!f_) f_ = (PFN_vkCmdSetEvent2)gdpa(device, "vkCmdSetEvent2KHR"); + if (f_) dt->vkCmdSetEvent2 = f_; + } + { + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT f_ = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)gdpa(device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT"); + if (f_) dt->vkCmdSetExtraPrimitiveOverestimationSizeEXT = f_; + } + { + PFN_vkCmdSetFragmentShadingRateKHR f_ = (PFN_vkCmdSetFragmentShadingRateKHR)gdpa(device, "vkCmdSetFragmentShadingRateKHR"); + if (f_) dt->vkCmdSetFragmentShadingRateKHR = f_; + } + { + PFN_vkCmdSetFrontFace f_ = (PFN_vkCmdSetFrontFace)gdpa(device, "vkCmdSetFrontFace"); + if (!f_) f_ = (PFN_vkCmdSetFrontFace)gdpa(device, "vkCmdSetFrontFaceEXT"); + if (f_) dt->vkCmdSetFrontFace = f_; + } + { + PFN_vkCmdSetLineRasterizationModeEXT f_ = (PFN_vkCmdSetLineRasterizationModeEXT)gdpa(device, "vkCmdSetLineRasterizationModeEXT"); + if (f_) dt->vkCmdSetLineRasterizationModeEXT = f_; + } + { + PFN_vkCmdSetLineStippleEXT f_ = (PFN_vkCmdSetLineStippleEXT)gdpa(device, "vkCmdSetLineStippleEXT"); + if (f_) dt->vkCmdSetLineStippleEXT = f_; + } + { + PFN_vkCmdSetLineStippleEnableEXT f_ = (PFN_vkCmdSetLineStippleEnableEXT)gdpa(device, "vkCmdSetLineStippleEnableEXT"); + if (f_) dt->vkCmdSetLineStippleEnableEXT = f_; + } + { + PFN_vkCmdSetLineWidth f_ = (PFN_vkCmdSetLineWidth)gdpa(device, "vkCmdSetLineWidth"); + if (f_) dt->vkCmdSetLineWidth = f_; + } + { + PFN_vkCmdSetLogicOpEXT f_ = (PFN_vkCmdSetLogicOpEXT)gdpa(device, "vkCmdSetLogicOpEXT"); + if (f_) dt->vkCmdSetLogicOpEXT = f_; + } + { + PFN_vkCmdSetLogicOpEnableEXT f_ = (PFN_vkCmdSetLogicOpEnableEXT)gdpa(device, "vkCmdSetLogicOpEnableEXT"); + if (f_) dt->vkCmdSetLogicOpEnableEXT = f_; + } + { + PFN_vkCmdSetPatchControlPointsEXT f_ = (PFN_vkCmdSetPatchControlPointsEXT)gdpa(device, "vkCmdSetPatchControlPointsEXT"); + if (f_) dt->vkCmdSetPatchControlPointsEXT = f_; + } + { + PFN_vkCmdSetPolygonModeEXT f_ = (PFN_vkCmdSetPolygonModeEXT)gdpa(device, "vkCmdSetPolygonModeEXT"); + if (f_) dt->vkCmdSetPolygonModeEXT = f_; + } + { + PFN_vkCmdSetPrimitiveRestartEnable f_ = (PFN_vkCmdSetPrimitiveRestartEnable)gdpa(device, "vkCmdSetPrimitiveRestartEnable"); + if (!f_) f_ = (PFN_vkCmdSetPrimitiveRestartEnable)gdpa(device, "vkCmdSetPrimitiveRestartEnableEXT"); + if (f_) dt->vkCmdSetPrimitiveRestartEnable = f_; + } + { + PFN_vkCmdSetPrimitiveTopology f_ = (PFN_vkCmdSetPrimitiveTopology)gdpa(device, "vkCmdSetPrimitiveTopology"); + if (!f_) f_ = (PFN_vkCmdSetPrimitiveTopology)gdpa(device, "vkCmdSetPrimitiveTopologyEXT"); + if (f_) dt->vkCmdSetPrimitiveTopology = f_; + } + { + PFN_vkCmdSetProvokingVertexModeEXT f_ = (PFN_vkCmdSetProvokingVertexModeEXT)gdpa(device, "vkCmdSetProvokingVertexModeEXT"); + if (f_) dt->vkCmdSetProvokingVertexModeEXT = f_; + } + { + PFN_vkCmdSetRasterizationSamplesEXT f_ = (PFN_vkCmdSetRasterizationSamplesEXT)gdpa(device, "vkCmdSetRasterizationSamplesEXT"); + if (f_) dt->vkCmdSetRasterizationSamplesEXT = f_; + } + { + PFN_vkCmdSetRasterizationStreamEXT f_ = (PFN_vkCmdSetRasterizationStreamEXT)gdpa(device, "vkCmdSetRasterizationStreamEXT"); + if (f_) dt->vkCmdSetRasterizationStreamEXT = f_; + } + { + PFN_vkCmdSetRasterizerDiscardEnable f_ = (PFN_vkCmdSetRasterizerDiscardEnable)gdpa(device, "vkCmdSetRasterizerDiscardEnable"); + if (!f_) f_ = (PFN_vkCmdSetRasterizerDiscardEnable)gdpa(device, "vkCmdSetRasterizerDiscardEnableEXT"); + if (f_) dt->vkCmdSetRasterizerDiscardEnable = f_; + } + { + PFN_vkCmdSetRepresentativeFragmentTestEnableNV f_ = (PFN_vkCmdSetRepresentativeFragmentTestEnableNV)gdpa(device, "vkCmdSetRepresentativeFragmentTestEnableNV"); + if (f_) dt->vkCmdSetRepresentativeFragmentTestEnableNV = f_; + } + { + PFN_vkCmdSetSampleLocationsEXT f_ = (PFN_vkCmdSetSampleLocationsEXT)gdpa(device, "vkCmdSetSampleLocationsEXT"); + if (f_) dt->vkCmdSetSampleLocationsEXT = f_; + } + { + PFN_vkCmdSetSampleLocationsEnableEXT f_ = (PFN_vkCmdSetSampleLocationsEnableEXT)gdpa(device, "vkCmdSetSampleLocationsEnableEXT"); + if (f_) dt->vkCmdSetSampleLocationsEnableEXT = f_; + } + { + PFN_vkCmdSetSampleMaskEXT f_ = (PFN_vkCmdSetSampleMaskEXT)gdpa(device, "vkCmdSetSampleMaskEXT"); + if (f_) dt->vkCmdSetSampleMaskEXT = f_; + } + { + PFN_vkCmdSetScissor f_ = (PFN_vkCmdSetScissor)gdpa(device, "vkCmdSetScissor"); + if (f_) dt->vkCmdSetScissor = f_; + } + { + PFN_vkCmdSetScissorWithCount f_ = (PFN_vkCmdSetScissorWithCount)gdpa(device, "vkCmdSetScissorWithCount"); + if (!f_) f_ = (PFN_vkCmdSetScissorWithCount)gdpa(device, "vkCmdSetScissorWithCountEXT"); + if (f_) dt->vkCmdSetScissorWithCount = f_; + } + { + PFN_vkCmdSetShadingRateImageEnableNV f_ = (PFN_vkCmdSetShadingRateImageEnableNV)gdpa(device, "vkCmdSetShadingRateImageEnableNV"); + if (f_) dt->vkCmdSetShadingRateImageEnableNV = f_; + } + { + PFN_vkCmdSetStencilCompareMask f_ = (PFN_vkCmdSetStencilCompareMask)gdpa(device, "vkCmdSetStencilCompareMask"); + if (f_) dt->vkCmdSetStencilCompareMask = f_; + } + { + PFN_vkCmdSetStencilOp f_ = (PFN_vkCmdSetStencilOp)gdpa(device, "vkCmdSetStencilOp"); + if (!f_) f_ = (PFN_vkCmdSetStencilOp)gdpa(device, "vkCmdSetStencilOpEXT"); + if (f_) dt->vkCmdSetStencilOp = f_; + } + { + PFN_vkCmdSetStencilReference f_ = (PFN_vkCmdSetStencilReference)gdpa(device, "vkCmdSetStencilReference"); + if (f_) dt->vkCmdSetStencilReference = f_; + } + { + PFN_vkCmdSetStencilTestEnable f_ = (PFN_vkCmdSetStencilTestEnable)gdpa(device, "vkCmdSetStencilTestEnable"); + if (!f_) f_ = (PFN_vkCmdSetStencilTestEnable)gdpa(device, "vkCmdSetStencilTestEnableEXT"); + if (f_) dt->vkCmdSetStencilTestEnable = f_; + } + { + PFN_vkCmdSetStencilWriteMask f_ = (PFN_vkCmdSetStencilWriteMask)gdpa(device, "vkCmdSetStencilWriteMask"); + if (f_) dt->vkCmdSetStencilWriteMask = f_; + } + { + PFN_vkCmdSetTessellationDomainOriginEXT f_ = (PFN_vkCmdSetTessellationDomainOriginEXT)gdpa(device, "vkCmdSetTessellationDomainOriginEXT"); + if (f_) dt->vkCmdSetTessellationDomainOriginEXT = f_; + } + { + PFN_vkCmdSetVertexInputEXT f_ = (PFN_vkCmdSetVertexInputEXT)gdpa(device, "vkCmdSetVertexInputEXT"); + if (f_) dt->vkCmdSetVertexInputEXT = f_; + } + { + PFN_vkCmdSetViewport f_ = (PFN_vkCmdSetViewport)gdpa(device, "vkCmdSetViewport"); + if (f_) dt->vkCmdSetViewport = f_; + } + { + PFN_vkCmdSetViewportSwizzleNV f_ = (PFN_vkCmdSetViewportSwizzleNV)gdpa(device, "vkCmdSetViewportSwizzleNV"); + if (f_) dt->vkCmdSetViewportSwizzleNV = f_; + } + { + PFN_vkCmdSetViewportWScalingEnableNV f_ = (PFN_vkCmdSetViewportWScalingEnableNV)gdpa(device, "vkCmdSetViewportWScalingEnableNV"); + if (f_) dt->vkCmdSetViewportWScalingEnableNV = f_; + } + { + PFN_vkCmdSetViewportWithCount f_ = (PFN_vkCmdSetViewportWithCount)gdpa(device, "vkCmdSetViewportWithCount"); + if (!f_) f_ = (PFN_vkCmdSetViewportWithCount)gdpa(device, "vkCmdSetViewportWithCountEXT"); + if (f_) dt->vkCmdSetViewportWithCount = f_; + } + { + PFN_vkCmdUpdateBuffer f_ = (PFN_vkCmdUpdateBuffer)gdpa(device, "vkCmdUpdateBuffer"); + if (f_) dt->vkCmdUpdateBuffer = f_; + } + { + PFN_vkCmdWaitEvents f_ = (PFN_vkCmdWaitEvents)gdpa(device, "vkCmdWaitEvents"); + if (f_) dt->vkCmdWaitEvents = f_; + } + { + PFN_vkCmdWaitEvents2 f_ = (PFN_vkCmdWaitEvents2)gdpa(device, "vkCmdWaitEvents2"); + if (!f_) f_ = (PFN_vkCmdWaitEvents2)gdpa(device, "vkCmdWaitEvents2KHR"); + if (f_) dt->vkCmdWaitEvents2 = f_; + } + { + PFN_vkCmdWriteTimestamp f_ = (PFN_vkCmdWriteTimestamp)gdpa(device, "vkCmdWriteTimestamp"); + if (f_) dt->vkCmdWriteTimestamp = f_; + } + { + PFN_vkCmdWriteTimestamp2 f_ = (PFN_vkCmdWriteTimestamp2)gdpa(device, "vkCmdWriteTimestamp2"); + if (!f_) f_ = (PFN_vkCmdWriteTimestamp2)gdpa(device, "vkCmdWriteTimestamp2KHR"); + if (f_) dt->vkCmdWriteTimestamp2 = f_; + } + { + PFN_vkCreateBuffer f_ = (PFN_vkCreateBuffer)gdpa(device, "vkCreateBuffer"); + if (f_) dt->vkCreateBuffer = f_; + } + { + PFN_vkCreateBufferView f_ = (PFN_vkCreateBufferView)gdpa(device, "vkCreateBufferView"); + if (f_) dt->vkCreateBufferView = f_; + } + { + PFN_vkCreateCommandPool f_ = (PFN_vkCreateCommandPool)gdpa(device, "vkCreateCommandPool"); + if (f_) dt->vkCreateCommandPool = f_; + } + { + PFN_vkCreateComputePipelines f_ = (PFN_vkCreateComputePipelines)gdpa(device, "vkCreateComputePipelines"); + if (f_) dt->vkCreateComputePipelines = f_; + } + { + PFN_vkCreateDescriptorPool f_ = (PFN_vkCreateDescriptorPool)gdpa(device, "vkCreateDescriptorPool"); + if (f_) dt->vkCreateDescriptorPool = f_; + } + { + PFN_vkCreateDescriptorSetLayout f_ = (PFN_vkCreateDescriptorSetLayout)gdpa(device, "vkCreateDescriptorSetLayout"); + if (f_) dt->vkCreateDescriptorSetLayout = f_; + } + { + PFN_vkCreateDescriptorUpdateTemplate f_ = (PFN_vkCreateDescriptorUpdateTemplate)gdpa(device, "vkCreateDescriptorUpdateTemplate"); + if (!f_) f_ = (PFN_vkCreateDescriptorUpdateTemplate)gdpa(device, "vkCreateDescriptorUpdateTemplateKHR"); + if (f_) dt->vkCreateDescriptorUpdateTemplate = f_; + } + { + PFN_vkCreateEvent f_ = (PFN_vkCreateEvent)gdpa(device, "vkCreateEvent"); + if (f_) dt->vkCreateEvent = f_; + } + { + PFN_vkCreateFence f_ = (PFN_vkCreateFence)gdpa(device, "vkCreateFence"); + if (f_) dt->vkCreateFence = f_; + } + { + PFN_vkCreateFramebuffer f_ = (PFN_vkCreateFramebuffer)gdpa(device, "vkCreateFramebuffer"); + if (f_) dt->vkCreateFramebuffer = f_; + } + { + PFN_vkCreateGraphicsPipelines f_ = (PFN_vkCreateGraphicsPipelines)gdpa(device, "vkCreateGraphicsPipelines"); + if (f_) dt->vkCreateGraphicsPipelines = f_; + } + { + PFN_vkCreateImage f_ = (PFN_vkCreateImage)gdpa(device, "vkCreateImage"); + if (f_) dt->vkCreateImage = f_; + } + { + PFN_vkCreateImageView f_ = (PFN_vkCreateImageView)gdpa(device, "vkCreateImageView"); + if (f_) dt->vkCreateImageView = f_; + } + { + PFN_vkCreatePipelineCache f_ = (PFN_vkCreatePipelineCache)gdpa(device, "vkCreatePipelineCache"); + if (f_) dt->vkCreatePipelineCache = f_; + } + { + PFN_vkCreatePipelineLayout f_ = (PFN_vkCreatePipelineLayout)gdpa(device, "vkCreatePipelineLayout"); + if (f_) dt->vkCreatePipelineLayout = f_; + } + { + PFN_vkCreateQueryPool f_ = (PFN_vkCreateQueryPool)gdpa(device, "vkCreateQueryPool"); + if (f_) dt->vkCreateQueryPool = f_; + } + { + PFN_vkCreateRenderPass f_ = (PFN_vkCreateRenderPass)gdpa(device, "vkCreateRenderPass"); + if (f_) dt->vkCreateRenderPass = f_; + } + { + PFN_vkCreateRenderPass2 f_ = (PFN_vkCreateRenderPass2)gdpa(device, "vkCreateRenderPass2"); + if (!f_) f_ = (PFN_vkCreateRenderPass2)gdpa(device, "vkCreateRenderPass2KHR"); + if (f_) dt->vkCreateRenderPass2 = f_; + } + { + PFN_vkCreateSampler f_ = (PFN_vkCreateSampler)gdpa(device, "vkCreateSampler"); + if (f_) dt->vkCreateSampler = f_; + } + { + PFN_vkCreateSamplerYcbcrConversion f_ = (PFN_vkCreateSamplerYcbcrConversion)gdpa(device, "vkCreateSamplerYcbcrConversion"); + if (!f_) f_ = (PFN_vkCreateSamplerYcbcrConversion)gdpa(device, "vkCreateSamplerYcbcrConversionKHR"); + if (f_) dt->vkCreateSamplerYcbcrConversion = f_; + } + { + PFN_vkCreateSemaphore f_ = (PFN_vkCreateSemaphore)gdpa(device, "vkCreateSemaphore"); + if (f_) dt->vkCreateSemaphore = f_; + } + { + PFN_vkCreateShaderModule f_ = (PFN_vkCreateShaderModule)gdpa(device, "vkCreateShaderModule"); + if (f_) dt->vkCreateShaderModule = f_; + } + { + PFN_vkDestroyBuffer f_ = (PFN_vkDestroyBuffer)gdpa(device, "vkDestroyBuffer"); + if (f_) dt->vkDestroyBuffer = f_; + } + { + PFN_vkDestroyBufferView f_ = (PFN_vkDestroyBufferView)gdpa(device, "vkDestroyBufferView"); + if (f_) dt->vkDestroyBufferView = f_; + } + { + PFN_vkDestroyCommandPool f_ = (PFN_vkDestroyCommandPool)gdpa(device, "vkDestroyCommandPool"); + if (f_) dt->vkDestroyCommandPool = f_; + } + { + PFN_vkDestroyDescriptorPool f_ = (PFN_vkDestroyDescriptorPool)gdpa(device, "vkDestroyDescriptorPool"); + if (f_) dt->vkDestroyDescriptorPool = f_; + } + { + PFN_vkDestroyDescriptorSetLayout f_ = (PFN_vkDestroyDescriptorSetLayout)gdpa(device, "vkDestroyDescriptorSetLayout"); + if (f_) dt->vkDestroyDescriptorSetLayout = f_; + } + { + PFN_vkDestroyDescriptorUpdateTemplate f_ = (PFN_vkDestroyDescriptorUpdateTemplate)gdpa(device, "vkDestroyDescriptorUpdateTemplate"); + if (!f_) f_ = (PFN_vkDestroyDescriptorUpdateTemplate)gdpa(device, "vkDestroyDescriptorUpdateTemplateKHR"); + if (f_) dt->vkDestroyDescriptorUpdateTemplate = f_; + } + { + PFN_vkDestroyDevice f_ = (PFN_vkDestroyDevice)gdpa(device, "vkDestroyDevice"); + if (f_) dt->vkDestroyDevice = f_; + } + { + PFN_vkDestroyEvent f_ = (PFN_vkDestroyEvent)gdpa(device, "vkDestroyEvent"); + if (f_) dt->vkDestroyEvent = f_; + } + { + PFN_vkDestroyFence f_ = (PFN_vkDestroyFence)gdpa(device, "vkDestroyFence"); + if (f_) dt->vkDestroyFence = f_; + } + { + PFN_vkDestroyFramebuffer f_ = (PFN_vkDestroyFramebuffer)gdpa(device, "vkDestroyFramebuffer"); + if (f_) dt->vkDestroyFramebuffer = f_; + } + { + PFN_vkDestroyImage f_ = (PFN_vkDestroyImage)gdpa(device, "vkDestroyImage"); + if (f_) dt->vkDestroyImage = f_; + } + { + PFN_vkDestroyImageView f_ = (PFN_vkDestroyImageView)gdpa(device, "vkDestroyImageView"); + if (f_) dt->vkDestroyImageView = f_; + } + { + PFN_vkDestroyPipeline f_ = (PFN_vkDestroyPipeline)gdpa(device, "vkDestroyPipeline"); + if (f_) dt->vkDestroyPipeline = f_; + } + { + PFN_vkDestroyPipelineCache f_ = (PFN_vkDestroyPipelineCache)gdpa(device, "vkDestroyPipelineCache"); + if (f_) dt->vkDestroyPipelineCache = f_; + } + { + PFN_vkDestroyPipelineLayout f_ = (PFN_vkDestroyPipelineLayout)gdpa(device, "vkDestroyPipelineLayout"); + if (f_) dt->vkDestroyPipelineLayout = f_; + } + { + PFN_vkDestroyQueryPool f_ = (PFN_vkDestroyQueryPool)gdpa(device, "vkDestroyQueryPool"); + if (f_) dt->vkDestroyQueryPool = f_; + } + { + PFN_vkDestroyRenderPass f_ = (PFN_vkDestroyRenderPass)gdpa(device, "vkDestroyRenderPass"); + if (f_) dt->vkDestroyRenderPass = f_; + } + { + PFN_vkDestroySampler f_ = (PFN_vkDestroySampler)gdpa(device, "vkDestroySampler"); + if (f_) dt->vkDestroySampler = f_; + } + { + PFN_vkDestroySamplerYcbcrConversion f_ = (PFN_vkDestroySamplerYcbcrConversion)gdpa(device, "vkDestroySamplerYcbcrConversion"); + if (!f_) f_ = (PFN_vkDestroySamplerYcbcrConversion)gdpa(device, "vkDestroySamplerYcbcrConversionKHR"); + if (f_) dt->vkDestroySamplerYcbcrConversion = f_; + } + { + PFN_vkDestroySemaphore f_ = (PFN_vkDestroySemaphore)gdpa(device, "vkDestroySemaphore"); + if (f_) dt->vkDestroySemaphore = f_; + } + { + PFN_vkDestroyShaderModule f_ = (PFN_vkDestroyShaderModule)gdpa(device, "vkDestroyShaderModule"); + if (f_) dt->vkDestroyShaderModule = f_; + } + { + PFN_vkDeviceWaitIdle f_ = (PFN_vkDeviceWaitIdle)gdpa(device, "vkDeviceWaitIdle"); + if (f_) dt->vkDeviceWaitIdle = f_; + } + { + PFN_vkEndCommandBuffer f_ = (PFN_vkEndCommandBuffer)gdpa(device, "vkEndCommandBuffer"); + if (f_) dt->vkEndCommandBuffer = f_; + } + { + PFN_vkFlushMappedMemoryRanges f_ = (PFN_vkFlushMappedMemoryRanges)gdpa(device, "vkFlushMappedMemoryRanges"); + if (f_) dt->vkFlushMappedMemoryRanges = f_; + } + { + PFN_vkFreeCommandBuffers f_ = (PFN_vkFreeCommandBuffers)gdpa(device, "vkFreeCommandBuffers"); + if (f_) dt->vkFreeCommandBuffers = f_; + } + { + PFN_vkFreeDescriptorSets f_ = (PFN_vkFreeDescriptorSets)gdpa(device, "vkFreeDescriptorSets"); + if (f_) dt->vkFreeDescriptorSets = f_; + } + { + PFN_vkFreeMemory f_ = (PFN_vkFreeMemory)gdpa(device, "vkFreeMemory"); + if (f_) dt->vkFreeMemory = f_; + } + { + PFN_vkGetBufferDeviceAddress f_ = (PFN_vkGetBufferDeviceAddress)gdpa(device, "vkGetBufferDeviceAddress"); + if (!f_) f_ = (PFN_vkGetBufferDeviceAddress)gdpa(device, "vkGetBufferDeviceAddressEXT"); + if (!f_) f_ = (PFN_vkGetBufferDeviceAddress)gdpa(device, "vkGetBufferDeviceAddressKHR"); + if (f_) dt->vkGetBufferDeviceAddress = f_; + } + { + PFN_vkGetBufferMemoryRequirements f_ = (PFN_vkGetBufferMemoryRequirements)gdpa(device, "vkGetBufferMemoryRequirements"); + if (f_) dt->vkGetBufferMemoryRequirements = f_; + } + { + PFN_vkGetBufferMemoryRequirements2 f_ = (PFN_vkGetBufferMemoryRequirements2)gdpa(device, "vkGetBufferMemoryRequirements2"); + if (!f_) f_ = (PFN_vkGetBufferMemoryRequirements2)gdpa(device, "vkGetBufferMemoryRequirements2KHR"); + if (f_) dt->vkGetBufferMemoryRequirements2 = f_; + } + { + PFN_vkGetBufferOpaqueCaptureAddress f_ = (PFN_vkGetBufferOpaqueCaptureAddress)gdpa(device, "vkGetBufferOpaqueCaptureAddress"); + if (!f_) f_ = (PFN_vkGetBufferOpaqueCaptureAddress)gdpa(device, "vkGetBufferOpaqueCaptureAddressKHR"); + if (f_) dt->vkGetBufferOpaqueCaptureAddress = f_; + } + { + PFN_vkGetCalibratedTimestampsEXT f_ = (PFN_vkGetCalibratedTimestampsEXT)gdpa(device, "vkGetCalibratedTimestampsEXT"); + if (f_) dt->vkGetCalibratedTimestampsEXT = f_; + } + { + PFN_vkGetDescriptorSetLayoutSupport f_ = (PFN_vkGetDescriptorSetLayoutSupport)gdpa(device, "vkGetDescriptorSetLayoutSupport"); + if (!f_) f_ = (PFN_vkGetDescriptorSetLayoutSupport)gdpa(device, "vkGetDescriptorSetLayoutSupportKHR"); + if (f_) dt->vkGetDescriptorSetLayoutSupport = f_; + } + { + PFN_vkGetDeviceBufferMemoryRequirements f_ = (PFN_vkGetDeviceBufferMemoryRequirements)gdpa(device, "vkGetDeviceBufferMemoryRequirements"); + if (!f_) f_ = (PFN_vkGetDeviceBufferMemoryRequirements)gdpa(device, "vkGetDeviceBufferMemoryRequirementsKHR"); + if (f_) dt->vkGetDeviceBufferMemoryRequirements = f_; + } + { + PFN_vkGetDeviceGroupPeerMemoryFeatures f_ = (PFN_vkGetDeviceGroupPeerMemoryFeatures)gdpa(device, "vkGetDeviceGroupPeerMemoryFeatures"); + if (!f_) f_ = (PFN_vkGetDeviceGroupPeerMemoryFeatures)gdpa(device, "vkGetDeviceGroupPeerMemoryFeaturesKHR"); + if (f_) dt->vkGetDeviceGroupPeerMemoryFeatures = f_; + } + { + PFN_vkGetDeviceImageMemoryRequirements f_ = (PFN_vkGetDeviceImageMemoryRequirements)gdpa(device, "vkGetDeviceImageMemoryRequirements"); + if (!f_) f_ = (PFN_vkGetDeviceImageMemoryRequirements)gdpa(device, "vkGetDeviceImageMemoryRequirementsKHR"); + if (f_) dt->vkGetDeviceImageMemoryRequirements = f_; + } + { + PFN_vkGetDeviceImageSparseMemoryRequirements f_ = (PFN_vkGetDeviceImageSparseMemoryRequirements)gdpa(device, "vkGetDeviceImageSparseMemoryRequirements"); + if (!f_) f_ = (PFN_vkGetDeviceImageSparseMemoryRequirements)gdpa(device, "vkGetDeviceImageSparseMemoryRequirementsKHR"); + if (f_) dt->vkGetDeviceImageSparseMemoryRequirements = f_; + } + { + PFN_vkGetDeviceMemoryCommitment f_ = (PFN_vkGetDeviceMemoryCommitment)gdpa(device, "vkGetDeviceMemoryCommitment"); + if (f_) dt->vkGetDeviceMemoryCommitment = f_; + } + { + PFN_vkGetDeviceMemoryOpaqueCaptureAddress f_ = (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)gdpa(device, "vkGetDeviceMemoryOpaqueCaptureAddress"); + if (!f_) f_ = (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)gdpa(device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"); + if (f_) dt->vkGetDeviceMemoryOpaqueCaptureAddress = f_; + } + { + PFN_vkGetDeviceQueue f_ = (PFN_vkGetDeviceQueue)gdpa(device, "vkGetDeviceQueue"); + if (f_) dt->vkGetDeviceQueue = f_; + } + { + PFN_vkGetDeviceQueue2 f_ = (PFN_vkGetDeviceQueue2)gdpa(device, "vkGetDeviceQueue2"); + if (f_) dt->vkGetDeviceQueue2 = f_; + } + { + PFN_vkGetEventStatus f_ = (PFN_vkGetEventStatus)gdpa(device, "vkGetEventStatus"); + if (f_) dt->vkGetEventStatus = f_; + } + { + PFN_vkGetFenceFdKHR f_ = (PFN_vkGetFenceFdKHR)gdpa(device, "vkGetFenceFdKHR"); + if (f_) dt->vkGetFenceFdKHR = f_; + } + { + PFN_vkGetFenceStatus f_ = (PFN_vkGetFenceStatus)gdpa(device, "vkGetFenceStatus"); + if (f_) dt->vkGetFenceStatus = f_; + } + { + PFN_vkGetImageDrmFormatModifierPropertiesEXT f_ = (PFN_vkGetImageDrmFormatModifierPropertiesEXT)gdpa(device, "vkGetImageDrmFormatModifierPropertiesEXT"); + if (f_) dt->vkGetImageDrmFormatModifierPropertiesEXT = f_; + } + { + PFN_vkGetImageMemoryRequirements f_ = (PFN_vkGetImageMemoryRequirements)gdpa(device, "vkGetImageMemoryRequirements"); + if (f_) dt->vkGetImageMemoryRequirements = f_; + } + { + PFN_vkGetImageMemoryRequirements2 f_ = (PFN_vkGetImageMemoryRequirements2)gdpa(device, "vkGetImageMemoryRequirements2"); + if (!f_) f_ = (PFN_vkGetImageMemoryRequirements2)gdpa(device, "vkGetImageMemoryRequirements2KHR"); + if (f_) dt->vkGetImageMemoryRequirements2 = f_; + } + { + PFN_vkGetImageSparseMemoryRequirements f_ = (PFN_vkGetImageSparseMemoryRequirements)gdpa(device, "vkGetImageSparseMemoryRequirements"); + if (f_) dt->vkGetImageSparseMemoryRequirements = f_; + } + { + PFN_vkGetImageSparseMemoryRequirements2 f_ = (PFN_vkGetImageSparseMemoryRequirements2)gdpa(device, "vkGetImageSparseMemoryRequirements2"); + if (!f_) f_ = (PFN_vkGetImageSparseMemoryRequirements2)gdpa(device, "vkGetImageSparseMemoryRequirements2KHR"); + if (f_) dt->vkGetImageSparseMemoryRequirements2 = f_; + } + { + PFN_vkGetImageSubresourceLayout f_ = (PFN_vkGetImageSubresourceLayout)gdpa(device, "vkGetImageSubresourceLayout"); + if (f_) dt->vkGetImageSubresourceLayout = f_; + } + { + PFN_vkGetImageSubresourceLayout2EXT f_ = (PFN_vkGetImageSubresourceLayout2EXT)gdpa(device, "vkGetImageSubresourceLayout2EXT"); + if (f_) dt->vkGetImageSubresourceLayout2EXT = f_; + } + { + PFN_vkGetMemoryFdKHR f_ = (PFN_vkGetMemoryFdKHR)gdpa(device, "vkGetMemoryFdKHR"); + if (f_) dt->vkGetMemoryFdKHR = f_; + } + { + PFN_vkGetMemoryFdPropertiesKHR f_ = (PFN_vkGetMemoryFdPropertiesKHR)gdpa(device, "vkGetMemoryFdPropertiesKHR"); + if (f_) dt->vkGetMemoryFdPropertiesKHR = f_; + } + { + PFN_vkGetMemoryHostPointerPropertiesEXT f_ = (PFN_vkGetMemoryHostPointerPropertiesEXT)gdpa(device, "vkGetMemoryHostPointerPropertiesEXT"); + if (f_) dt->vkGetMemoryHostPointerPropertiesEXT = f_; + } + { + PFN_vkGetPipelineCacheData f_ = (PFN_vkGetPipelineCacheData)gdpa(device, "vkGetPipelineCacheData"); + if (f_) dt->vkGetPipelineCacheData = f_; + } + { + PFN_vkGetQueryPoolResults f_ = (PFN_vkGetQueryPoolResults)gdpa(device, "vkGetQueryPoolResults"); + if (f_) dt->vkGetQueryPoolResults = f_; + } + { + PFN_vkGetRenderAreaGranularity f_ = (PFN_vkGetRenderAreaGranularity)gdpa(device, "vkGetRenderAreaGranularity"); + if (f_) dt->vkGetRenderAreaGranularity = f_; + } + { + PFN_vkGetSemaphoreCounterValue f_ = (PFN_vkGetSemaphoreCounterValue)gdpa(device, "vkGetSemaphoreCounterValue"); + if (!f_) f_ = (PFN_vkGetSemaphoreCounterValue)gdpa(device, "vkGetSemaphoreCounterValueKHR"); + if (f_) dt->vkGetSemaphoreCounterValue = f_; + } + { + PFN_vkGetSemaphoreFdKHR f_ = (PFN_vkGetSemaphoreFdKHR)gdpa(device, "vkGetSemaphoreFdKHR"); + if (f_) dt->vkGetSemaphoreFdKHR = f_; + } + { + PFN_vkGetShaderModuleCreateInfoIdentifierEXT f_ = (PFN_vkGetShaderModuleCreateInfoIdentifierEXT)gdpa(device, "vkGetShaderModuleCreateInfoIdentifierEXT"); + if (f_) dt->vkGetShaderModuleCreateInfoIdentifierEXT = f_; + } + { + PFN_vkGetShaderModuleIdentifierEXT f_ = (PFN_vkGetShaderModuleIdentifierEXT)gdpa(device, "vkGetShaderModuleIdentifierEXT"); + if (f_) dt->vkGetShaderModuleIdentifierEXT = f_; + } + { + PFN_vkImportFenceFdKHR f_ = (PFN_vkImportFenceFdKHR)gdpa(device, "vkImportFenceFdKHR"); + if (f_) dt->vkImportFenceFdKHR = f_; + } + { + PFN_vkImportSemaphoreFdKHR f_ = (PFN_vkImportSemaphoreFdKHR)gdpa(device, "vkImportSemaphoreFdKHR"); + if (f_) dt->vkImportSemaphoreFdKHR = f_; + } + { + PFN_vkInvalidateMappedMemoryRanges f_ = (PFN_vkInvalidateMappedMemoryRanges)gdpa(device, "vkInvalidateMappedMemoryRanges"); + if (f_) dt->vkInvalidateMappedMemoryRanges = f_; + } + { + PFN_vkMapMemory f_ = (PFN_vkMapMemory)gdpa(device, "vkMapMemory"); + if (f_) dt->vkMapMemory = f_; + } + { + PFN_vkMergePipelineCaches f_ = (PFN_vkMergePipelineCaches)gdpa(device, "vkMergePipelineCaches"); + if (f_) dt->vkMergePipelineCaches = f_; + } + { + PFN_vkQueueBindSparse f_ = (PFN_vkQueueBindSparse)gdpa(device, "vkQueueBindSparse"); + if (f_) dt->vkQueueBindSparse = f_; + } + { + PFN_vkQueueSubmit f_ = (PFN_vkQueueSubmit)gdpa(device, "vkQueueSubmit"); + if (f_) dt->vkQueueSubmit = f_; + } + { + PFN_vkQueueSubmit2 f_ = (PFN_vkQueueSubmit2)gdpa(device, "vkQueueSubmit2"); + if (!f_) f_ = (PFN_vkQueueSubmit2)gdpa(device, "vkQueueSubmit2KHR"); + if (f_) dt->vkQueueSubmit2 = f_; + } + { + PFN_vkQueueWaitIdle f_ = (PFN_vkQueueWaitIdle)gdpa(device, "vkQueueWaitIdle"); + if (f_) dt->vkQueueWaitIdle = f_; + } + { + PFN_vkResetCommandBuffer f_ = (PFN_vkResetCommandBuffer)gdpa(device, "vkResetCommandBuffer"); + if (f_) dt->vkResetCommandBuffer = f_; + } + { + PFN_vkResetCommandPool f_ = (PFN_vkResetCommandPool)gdpa(device, "vkResetCommandPool"); + if (f_) dt->vkResetCommandPool = f_; + } + { + PFN_vkResetDescriptorPool f_ = (PFN_vkResetDescriptorPool)gdpa(device, "vkResetDescriptorPool"); + if (f_) dt->vkResetDescriptorPool = f_; + } + { + PFN_vkResetEvent f_ = (PFN_vkResetEvent)gdpa(device, "vkResetEvent"); + if (f_) dt->vkResetEvent = f_; + } + { + PFN_vkResetFences f_ = (PFN_vkResetFences)gdpa(device, "vkResetFences"); + if (f_) dt->vkResetFences = f_; + } + { + PFN_vkResetQueryPool f_ = (PFN_vkResetQueryPool)gdpa(device, "vkResetQueryPool"); + if (!f_) f_ = (PFN_vkResetQueryPool)gdpa(device, "vkResetQueryPoolEXT"); + if (f_) dt->vkResetQueryPool = f_; + } + { + PFN_vkSetDeviceMemoryPriorityEXT f_ = (PFN_vkSetDeviceMemoryPriorityEXT)gdpa(device, "vkSetDeviceMemoryPriorityEXT"); + if (f_) dt->vkSetDeviceMemoryPriorityEXT = f_; + } + { + PFN_vkSetEvent f_ = (PFN_vkSetEvent)gdpa(device, "vkSetEvent"); + if (f_) dt->vkSetEvent = f_; + } + { + PFN_vkSignalSemaphore f_ = (PFN_vkSignalSemaphore)gdpa(device, "vkSignalSemaphore"); + if (!f_) f_ = (PFN_vkSignalSemaphore)gdpa(device, "vkSignalSemaphoreKHR"); + if (f_) dt->vkSignalSemaphore = f_; + } + { + PFN_vkTrimCommandPool f_ = (PFN_vkTrimCommandPool)gdpa(device, "vkTrimCommandPool"); + if (!f_) f_ = (PFN_vkTrimCommandPool)gdpa(device, "vkTrimCommandPoolKHR"); + if (f_) dt->vkTrimCommandPool = f_; + } + { + PFN_vkUnmapMemory f_ = (PFN_vkUnmapMemory)gdpa(device, "vkUnmapMemory"); + if (f_) dt->vkUnmapMemory = f_; + } + { + PFN_vkUpdateDescriptorSetWithTemplate f_ = (PFN_vkUpdateDescriptorSetWithTemplate)gdpa(device, "vkUpdateDescriptorSetWithTemplate"); + if (!f_) f_ = (PFN_vkUpdateDescriptorSetWithTemplate)gdpa(device, "vkUpdateDescriptorSetWithTemplateKHR"); + if (f_) dt->vkUpdateDescriptorSetWithTemplate = f_; + } + { + PFN_vkUpdateDescriptorSets f_ = (PFN_vkUpdateDescriptorSets)gdpa(device, "vkUpdateDescriptorSets"); + if (f_) dt->vkUpdateDescriptorSets = f_; + } + { + PFN_vkWaitForFences f_ = (PFN_vkWaitForFences)gdpa(device, "vkWaitForFences"); + if (f_) dt->vkWaitForFences = f_; + } + { + PFN_vkWaitSemaphores f_ = (PFN_vkWaitSemaphores)gdpa(device, "vkWaitSemaphores"); + if (!f_) f_ = (PFN_vkWaitSemaphores)gdpa(device, "vkWaitSemaphoresKHR"); + if (f_) dt->vkWaitSemaphores = f_; + } +} + +void vkb_sv_vkAllocateCommandBuffers(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkCommandBufferAllocateInfo *pAllocateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCommandBufferAllocateInfo *a_ = (VkCommandBufferAllocateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCommandBufferAllocateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkCommandBufferAllocateInfo(d, &a_[i_]); + pAllocateInfo = a_; + } else { + pAllocateInfo = NULL; + } + uint8_t has_pCommandBuffers = vkb_dec_u8(d); uint32_t n_pCommandBuffers = vkb_dec_u32(d); + VkCommandBuffer *pCommandBuffers = has_pCommandBuffers ? (VkCommandBuffer *)vkb_dec_alloc_zero(d, (size_t)n_pCommandBuffers * sizeof(VkCommandBuffer)) : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkAllocateCommandBuffers) { vkb_srv_missing(c, "vkAllocateCommandBuffers"); return; } + VkResult r_ = c->dt->vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); + vkb_enc_bytes(e, &r_, sizeof(r_)); + { + uint32_t rn_ = n_pCommandBuffers; + uint32_t has_ = pCommandBuffers ? (rn_ < n_pCommandBuffers ? rn_ : n_pCommandBuffers) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_u64(e, (uint64_t)(uintptr_t)pCommandBuffers[i_]); + } +} + +void vkb_sv_vkAllocateDescriptorSets(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkDescriptorSetAllocateInfo *pAllocateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDescriptorSetAllocateInfo *a_ = (VkDescriptorSetAllocateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDescriptorSetAllocateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDescriptorSetAllocateInfo(d, &a_[i_]); + pAllocateInfo = a_; + } else { + pAllocateInfo = NULL; + } + uint8_t has_pDescriptorSets = vkb_dec_u8(d); uint32_t n_pDescriptorSets = vkb_dec_u32(d); + VkDescriptorSet *pDescriptorSets = has_pDescriptorSets ? (VkDescriptorSet *)vkb_dec_alloc_zero(d, (size_t)n_pDescriptorSets * sizeof(VkDescriptorSet)) : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkAllocateDescriptorSets) { vkb_srv_missing(c, "vkAllocateDescriptorSets"); return; } + VkResult r_ = c->dt->vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); + vkb_enc_bytes(e, &r_, sizeof(r_)); + { + uint32_t rn_ = n_pDescriptorSets; + uint32_t has_ = pDescriptorSets ? (rn_ < n_pDescriptorSets ? rn_ : n_pDescriptorSets) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &pDescriptorSets[i_], sizeof(VkDescriptorSet)); + } +} + +void vkb_sv_vkBeginCommandBuffer(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkCommandBufferBeginInfo *pBeginInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCommandBufferBeginInfo *a_ = (VkCommandBufferBeginInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCommandBufferBeginInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkCommandBufferBeginInfo(d, &a_[i_]); + pBeginInfo = a_; + } else { + pBeginInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkBeginCommandBuffer) { vkb_srv_missing(c, "vkBeginCommandBuffer"); return; } + VkResult r_ = c->dt->vkBeginCommandBuffer(commandBuffer, pBeginInfo); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkBindBufferMemory(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkBuffer buffer; + vkb_dec_bytes(d, &buffer, sizeof(buffer)); + VkDeviceMemory memory; + vkb_dec_bytes(d, &memory, sizeof(memory)); + VkDeviceSize memoryOffset; + vkb_dec_bytes(d, &memoryOffset, sizeof(memoryOffset)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkBindBufferMemory) { vkb_srv_missing(c, "vkBindBufferMemory"); return; } + VkResult r_ = c->dt->vkBindBufferMemory(device, buffer, memory, memoryOffset); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkBindBufferMemory2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + uint32_t bindInfoCount; + vkb_dec_bytes(d, &bindInfoCount, sizeof(bindInfoCount)); + const VkBindBufferMemoryInfo *pBindInfos; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBindBufferMemoryInfo *a_ = (VkBindBufferMemoryInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBindBufferMemoryInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBindBufferMemoryInfo(d, &a_[i_]); + pBindInfos = a_; + } else { + pBindInfos = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkBindBufferMemory2) { vkb_srv_missing(c, "vkBindBufferMemory2"); return; } + VkResult r_ = c->dt->vkBindBufferMemory2(device, bindInfoCount, pBindInfos); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkBindImageMemory(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkImage image; + vkb_dec_bytes(d, &image, sizeof(image)); + VkDeviceMemory memory; + vkb_dec_bytes(d, &memory, sizeof(memory)); + VkDeviceSize memoryOffset; + vkb_dec_bytes(d, &memoryOffset, sizeof(memoryOffset)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkBindImageMemory) { vkb_srv_missing(c, "vkBindImageMemory"); return; } + VkResult r_ = c->dt->vkBindImageMemory(device, image, memory, memoryOffset); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkBindImageMemory2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + uint32_t bindInfoCount; + vkb_dec_bytes(d, &bindInfoCount, sizeof(bindInfoCount)); + const VkBindImageMemoryInfo *pBindInfos; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBindImageMemoryInfo *a_ = (VkBindImageMemoryInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBindImageMemoryInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBindImageMemoryInfo(d, &a_[i_]); + pBindInfos = a_; + } else { + pBindInfos = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkBindImageMemory2) { vkb_srv_missing(c, "vkBindImageMemory2"); return; } + VkResult r_ = c->dt->vkBindImageMemory2(device, bindInfoCount, pBindInfos); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkCmdBeginConditionalRenderingEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkConditionalRenderingBeginInfoEXT *a_ = (VkConditionalRenderingBeginInfoEXT *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkConditionalRenderingBeginInfoEXT)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkConditionalRenderingBeginInfoEXT(d, &a_[i_]); + pConditionalRenderingBegin = a_; + } else { + pConditionalRenderingBegin = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBeginConditionalRenderingEXT) { vkb_srv_missing(c, "vkCmdBeginConditionalRenderingEXT"); return; } + c->dt->vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); +} + +void vkb_sv_vkCmdBeginQuery(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkQueryPool queryPool; + vkb_dec_bytes(d, &queryPool, sizeof(queryPool)); + uint32_t query; + vkb_dec_bytes(d, &query, sizeof(query)); + VkQueryControlFlags flags; + vkb_dec_bytes(d, &flags, sizeof(flags)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBeginQuery) { vkb_srv_missing(c, "vkCmdBeginQuery"); return; } + c->dt->vkCmdBeginQuery(commandBuffer, queryPool, query, flags); +} + +void vkb_sv_vkCmdBeginQueryIndexedEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkQueryPool queryPool; + vkb_dec_bytes(d, &queryPool, sizeof(queryPool)); + uint32_t query; + vkb_dec_bytes(d, &query, sizeof(query)); + VkQueryControlFlags flags; + vkb_dec_bytes(d, &flags, sizeof(flags)); + uint32_t index; + vkb_dec_bytes(d, &index, sizeof(index)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBeginQueryIndexedEXT) { vkb_srv_missing(c, "vkCmdBeginQueryIndexedEXT"); return; } + c->dt->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); +} + +void vkb_sv_vkCmdBeginRenderPass(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkRenderPassBeginInfo *pRenderPassBegin; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkRenderPassBeginInfo *a_ = (VkRenderPassBeginInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkRenderPassBeginInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkRenderPassBeginInfo(d, &a_[i_]); + pRenderPassBegin = a_; + } else { + pRenderPassBegin = NULL; + } + VkSubpassContents contents; + vkb_dec_bytes(d, &contents, sizeof(contents)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBeginRenderPass) { vkb_srv_missing(c, "vkCmdBeginRenderPass"); return; } + c->dt->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); +} + +void vkb_sv_vkCmdBeginRenderPass2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkRenderPassBeginInfo *pRenderPassBegin; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkRenderPassBeginInfo *a_ = (VkRenderPassBeginInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkRenderPassBeginInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkRenderPassBeginInfo(d, &a_[i_]); + pRenderPassBegin = a_; + } else { + pRenderPassBegin = NULL; + } + const VkSubpassBeginInfo *pSubpassBeginInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSubpassBeginInfo *a_ = (VkSubpassBeginInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSubpassBeginInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSubpassBeginInfo(d, &a_[i_]); + pSubpassBeginInfo = a_; + } else { + pSubpassBeginInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBeginRenderPass2) { vkb_srv_missing(c, "vkCmdBeginRenderPass2"); return; } + c->dt->vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); +} + +void vkb_sv_vkCmdBeginRendering(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkRenderingInfo *pRenderingInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkRenderingInfo *a_ = (VkRenderingInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkRenderingInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkRenderingInfo(d, &a_[i_]); + pRenderingInfo = a_; + } else { + pRenderingInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBeginRendering) { vkb_srv_missing(c, "vkCmdBeginRendering"); return; } + c->dt->vkCmdBeginRendering(commandBuffer, pRenderingInfo); +} + +void vkb_sv_vkCmdBeginTransformFeedbackEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstCounterBuffer; + vkb_dec_bytes(d, &firstCounterBuffer, sizeof(firstCounterBuffer)); + uint32_t counterBufferCount; + vkb_dec_bytes(d, &counterBufferCount, sizeof(counterBufferCount)); + const VkBuffer *pCounterBuffers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pCounterBuffers = (const VkBuffer *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBuffer)); + } else { + pCounterBuffers = NULL; + } + const VkDeviceSize *pCounterBufferOffsets; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pCounterBufferOffsets = (const VkDeviceSize *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDeviceSize)); + } else { + pCounterBufferOffsets = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBeginTransformFeedbackEXT) { vkb_srv_missing(c, "vkCmdBeginTransformFeedbackEXT"); return; } + c->dt->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); +} + +void vkb_sv_vkCmdBindDescriptorSets(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkPipelineBindPoint pipelineBindPoint; + vkb_dec_bytes(d, &pipelineBindPoint, sizeof(pipelineBindPoint)); + VkPipelineLayout layout; + vkb_dec_bytes(d, &layout, sizeof(layout)); + uint32_t firstSet; + vkb_dec_bytes(d, &firstSet, sizeof(firstSet)); + uint32_t descriptorSetCount; + vkb_dec_bytes(d, &descriptorSetCount, sizeof(descriptorSetCount)); + const VkDescriptorSet *pDescriptorSets; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pDescriptorSets = (const VkDescriptorSet *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDescriptorSet)); + } else { + pDescriptorSets = NULL; + } + uint32_t dynamicOffsetCount; + vkb_dec_bytes(d, &dynamicOffsetCount, sizeof(dynamicOffsetCount)); + const uint32_t *pDynamicOffsets; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pDynamicOffsets = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + pDynamicOffsets = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBindDescriptorSets) { vkb_srv_missing(c, "vkCmdBindDescriptorSets"); return; } + c->dt->vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); +} + +void vkb_sv_vkCmdBindIndexBuffer(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBuffer buffer; + vkb_dec_bytes(d, &buffer, sizeof(buffer)); + VkDeviceSize offset; + vkb_dec_bytes(d, &offset, sizeof(offset)); + VkIndexType indexType; + vkb_dec_bytes(d, &indexType, sizeof(indexType)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBindIndexBuffer) { vkb_srv_missing(c, "vkCmdBindIndexBuffer"); return; } + c->dt->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); +} + +void vkb_sv_vkCmdBindPipeline(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkPipelineBindPoint pipelineBindPoint; + vkb_dec_bytes(d, &pipelineBindPoint, sizeof(pipelineBindPoint)); + VkPipeline pipeline; + vkb_dec_bytes(d, &pipeline, sizeof(pipeline)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBindPipeline) { vkb_srv_missing(c, "vkCmdBindPipeline"); return; } + c->dt->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); +} + +void vkb_sv_vkCmdBindTransformFeedbackBuffersEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstBinding; + vkb_dec_bytes(d, &firstBinding, sizeof(firstBinding)); + uint32_t bindingCount; + vkb_dec_bytes(d, &bindingCount, sizeof(bindingCount)); + const VkBuffer *pBuffers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pBuffers = (const VkBuffer *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBuffer)); + } else { + pBuffers = NULL; + } + const VkDeviceSize *pOffsets; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pOffsets = (const VkDeviceSize *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDeviceSize)); + } else { + pOffsets = NULL; + } + const VkDeviceSize *pSizes; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pSizes = (const VkDeviceSize *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDeviceSize)); + } else { + pSizes = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBindTransformFeedbackBuffersEXT) { vkb_srv_missing(c, "vkCmdBindTransformFeedbackBuffersEXT"); return; } + c->dt->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); +} + +void vkb_sv_vkCmdBindVertexBuffers(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstBinding; + vkb_dec_bytes(d, &firstBinding, sizeof(firstBinding)); + uint32_t bindingCount; + vkb_dec_bytes(d, &bindingCount, sizeof(bindingCount)); + const VkBuffer *pBuffers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pBuffers = (const VkBuffer *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBuffer)); + } else { + pBuffers = NULL; + } + const VkDeviceSize *pOffsets; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pOffsets = (const VkDeviceSize *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDeviceSize)); + } else { + pOffsets = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBindVertexBuffers) { vkb_srv_missing(c, "vkCmdBindVertexBuffers"); return; } + c->dt->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); +} + +void vkb_sv_vkCmdBindVertexBuffers2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstBinding; + vkb_dec_bytes(d, &firstBinding, sizeof(firstBinding)); + uint32_t bindingCount; + vkb_dec_bytes(d, &bindingCount, sizeof(bindingCount)); + const VkBuffer *pBuffers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pBuffers = (const VkBuffer *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBuffer)); + } else { + pBuffers = NULL; + } + const VkDeviceSize *pOffsets; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pOffsets = (const VkDeviceSize *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDeviceSize)); + } else { + pOffsets = NULL; + } + const VkDeviceSize *pSizes; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pSizes = (const VkDeviceSize *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDeviceSize)); + } else { + pSizes = NULL; + } + const VkDeviceSize *pStrides; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pStrides = (const VkDeviceSize *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDeviceSize)); + } else { + pStrides = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBindVertexBuffers2) { vkb_srv_missing(c, "vkCmdBindVertexBuffers2"); return; } + c->dt->vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); +} + +void vkb_sv_vkCmdBlitImage(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkImage srcImage; + vkb_dec_bytes(d, &srcImage, sizeof(srcImage)); + VkImageLayout srcImageLayout; + vkb_dec_bytes(d, &srcImageLayout, sizeof(srcImageLayout)); + VkImage dstImage; + vkb_dec_bytes(d, &dstImage, sizeof(dstImage)); + VkImageLayout dstImageLayout; + vkb_dec_bytes(d, &dstImageLayout, sizeof(dstImageLayout)); + uint32_t regionCount; + vkb_dec_bytes(d, ®ionCount, sizeof(regionCount)); + const VkImageBlit *pRegions; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pRegions = (const VkImageBlit *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkImageBlit)); + } else { + pRegions = NULL; + } + VkFilter filter; + vkb_dec_bytes(d, &filter, sizeof(filter)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBlitImage) { vkb_srv_missing(c, "vkCmdBlitImage"); return; } + c->dt->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); +} + +void vkb_sv_vkCmdBlitImage2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkBlitImageInfo2 *pBlitImageInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBlitImageInfo2 *a_ = (VkBlitImageInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBlitImageInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBlitImageInfo2(d, &a_[i_]); + pBlitImageInfo = a_; + } else { + pBlitImageInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdBlitImage2) { vkb_srv_missing(c, "vkCmdBlitImage2"); return; } + c->dt->vkCmdBlitImage2(commandBuffer, pBlitImageInfo); +} + +void vkb_sv_vkCmdClearAttachments(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t attachmentCount; + vkb_dec_bytes(d, &attachmentCount, sizeof(attachmentCount)); + const VkClearAttachment *pAttachments; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pAttachments = (const VkClearAttachment *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkClearAttachment)); + } else { + pAttachments = NULL; + } + uint32_t rectCount; + vkb_dec_bytes(d, &rectCount, sizeof(rectCount)); + const VkClearRect *pRects; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pRects = (const VkClearRect *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkClearRect)); + } else { + pRects = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdClearAttachments) { vkb_srv_missing(c, "vkCmdClearAttachments"); return; } + c->dt->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); +} + +void vkb_sv_vkCmdClearColorImage(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkImage image; + vkb_dec_bytes(d, &image, sizeof(image)); + VkImageLayout imageLayout; + vkb_dec_bytes(d, &imageLayout, sizeof(imageLayout)); + const VkClearColorValue *pColor; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pColor = (const VkClearColorValue *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkClearColorValue)); + } else { + pColor = NULL; + } + uint32_t rangeCount; + vkb_dec_bytes(d, &rangeCount, sizeof(rangeCount)); + const VkImageSubresourceRange *pRanges; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pRanges = (const VkImageSubresourceRange *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkImageSubresourceRange)); + } else { + pRanges = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdClearColorImage) { vkb_srv_missing(c, "vkCmdClearColorImage"); return; } + c->dt->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); +} + +void vkb_sv_vkCmdClearDepthStencilImage(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkImage image; + vkb_dec_bytes(d, &image, sizeof(image)); + VkImageLayout imageLayout; + vkb_dec_bytes(d, &imageLayout, sizeof(imageLayout)); + const VkClearDepthStencilValue *pDepthStencil; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pDepthStencil = (const VkClearDepthStencilValue *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkClearDepthStencilValue)); + } else { + pDepthStencil = NULL; + } + uint32_t rangeCount; + vkb_dec_bytes(d, &rangeCount, sizeof(rangeCount)); + const VkImageSubresourceRange *pRanges; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pRanges = (const VkImageSubresourceRange *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkImageSubresourceRange)); + } else { + pRanges = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdClearDepthStencilImage) { vkb_srv_missing(c, "vkCmdClearDepthStencilImage"); return; } + c->dt->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); +} + +void vkb_sv_vkCmdCopyBuffer(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBuffer srcBuffer; + vkb_dec_bytes(d, &srcBuffer, sizeof(srcBuffer)); + VkBuffer dstBuffer; + vkb_dec_bytes(d, &dstBuffer, sizeof(dstBuffer)); + uint32_t regionCount; + vkb_dec_bytes(d, ®ionCount, sizeof(regionCount)); + const VkBufferCopy *pRegions; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pRegions = (const VkBufferCopy *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBufferCopy)); + } else { + pRegions = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdCopyBuffer) { vkb_srv_missing(c, "vkCmdCopyBuffer"); return; } + c->dt->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); +} + +void vkb_sv_vkCmdCopyBuffer2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkCopyBufferInfo2 *pCopyBufferInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCopyBufferInfo2 *a_ = (VkCopyBufferInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCopyBufferInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkCopyBufferInfo2(d, &a_[i_]); + pCopyBufferInfo = a_; + } else { + pCopyBufferInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdCopyBuffer2) { vkb_srv_missing(c, "vkCmdCopyBuffer2"); return; } + c->dt->vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo); +} + +void vkb_sv_vkCmdCopyBufferToImage(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBuffer srcBuffer; + vkb_dec_bytes(d, &srcBuffer, sizeof(srcBuffer)); + VkImage dstImage; + vkb_dec_bytes(d, &dstImage, sizeof(dstImage)); + VkImageLayout dstImageLayout; + vkb_dec_bytes(d, &dstImageLayout, sizeof(dstImageLayout)); + uint32_t regionCount; + vkb_dec_bytes(d, ®ionCount, sizeof(regionCount)); + const VkBufferImageCopy *pRegions; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pRegions = (const VkBufferImageCopy *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBufferImageCopy)); + } else { + pRegions = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdCopyBufferToImage) { vkb_srv_missing(c, "vkCmdCopyBufferToImage"); return; } + c->dt->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); +} + +void vkb_sv_vkCmdCopyBufferToImage2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCopyBufferToImageInfo2 *a_ = (VkCopyBufferToImageInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCopyBufferToImageInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkCopyBufferToImageInfo2(d, &a_[i_]); + pCopyBufferToImageInfo = a_; + } else { + pCopyBufferToImageInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdCopyBufferToImage2) { vkb_srv_missing(c, "vkCmdCopyBufferToImage2"); return; } + c->dt->vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); +} + +void vkb_sv_vkCmdCopyImage(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkImage srcImage; + vkb_dec_bytes(d, &srcImage, sizeof(srcImage)); + VkImageLayout srcImageLayout; + vkb_dec_bytes(d, &srcImageLayout, sizeof(srcImageLayout)); + VkImage dstImage; + vkb_dec_bytes(d, &dstImage, sizeof(dstImage)); + VkImageLayout dstImageLayout; + vkb_dec_bytes(d, &dstImageLayout, sizeof(dstImageLayout)); + uint32_t regionCount; + vkb_dec_bytes(d, ®ionCount, sizeof(regionCount)); + const VkImageCopy *pRegions; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pRegions = (const VkImageCopy *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkImageCopy)); + } else { + pRegions = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdCopyImage) { vkb_srv_missing(c, "vkCmdCopyImage"); return; } + c->dt->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); +} + +void vkb_sv_vkCmdCopyImage2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkCopyImageInfo2 *pCopyImageInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCopyImageInfo2 *a_ = (VkCopyImageInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCopyImageInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkCopyImageInfo2(d, &a_[i_]); + pCopyImageInfo = a_; + } else { + pCopyImageInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdCopyImage2) { vkb_srv_missing(c, "vkCmdCopyImage2"); return; } + c->dt->vkCmdCopyImage2(commandBuffer, pCopyImageInfo); +} + +void vkb_sv_vkCmdCopyImageToBuffer(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkImage srcImage; + vkb_dec_bytes(d, &srcImage, sizeof(srcImage)); + VkImageLayout srcImageLayout; + vkb_dec_bytes(d, &srcImageLayout, sizeof(srcImageLayout)); + VkBuffer dstBuffer; + vkb_dec_bytes(d, &dstBuffer, sizeof(dstBuffer)); + uint32_t regionCount; + vkb_dec_bytes(d, ®ionCount, sizeof(regionCount)); + const VkBufferImageCopy *pRegions; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pRegions = (const VkBufferImageCopy *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBufferImageCopy)); + } else { + pRegions = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdCopyImageToBuffer) { vkb_srv_missing(c, "vkCmdCopyImageToBuffer"); return; } + c->dt->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); +} + +void vkb_sv_vkCmdCopyImageToBuffer2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCopyImageToBufferInfo2 *a_ = (VkCopyImageToBufferInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCopyImageToBufferInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkCopyImageToBufferInfo2(d, &a_[i_]); + pCopyImageToBufferInfo = a_; + } else { + pCopyImageToBufferInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdCopyImageToBuffer2) { vkb_srv_missing(c, "vkCmdCopyImageToBuffer2"); return; } + c->dt->vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); +} + +void vkb_sv_vkCmdCopyQueryPoolResults(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkQueryPool queryPool; + vkb_dec_bytes(d, &queryPool, sizeof(queryPool)); + uint32_t firstQuery; + vkb_dec_bytes(d, &firstQuery, sizeof(firstQuery)); + uint32_t queryCount; + vkb_dec_bytes(d, &queryCount, sizeof(queryCount)); + VkBuffer dstBuffer; + vkb_dec_bytes(d, &dstBuffer, sizeof(dstBuffer)); + VkDeviceSize dstOffset; + vkb_dec_bytes(d, &dstOffset, sizeof(dstOffset)); + VkDeviceSize stride; + vkb_dec_bytes(d, &stride, sizeof(stride)); + VkQueryResultFlags flags; + vkb_dec_bytes(d, &flags, sizeof(flags)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdCopyQueryPoolResults) { vkb_srv_missing(c, "vkCmdCopyQueryPoolResults"); return; } + c->dt->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); +} + +void vkb_sv_vkCmdDispatch(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t groupCountX; + vkb_dec_bytes(d, &groupCountX, sizeof(groupCountX)); + uint32_t groupCountY; + vkb_dec_bytes(d, &groupCountY, sizeof(groupCountY)); + uint32_t groupCountZ; + vkb_dec_bytes(d, &groupCountZ, sizeof(groupCountZ)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDispatch) { vkb_srv_missing(c, "vkCmdDispatch"); return; } + c->dt->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); +} + +void vkb_sv_vkCmdDispatchBase(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t baseGroupX; + vkb_dec_bytes(d, &baseGroupX, sizeof(baseGroupX)); + uint32_t baseGroupY; + vkb_dec_bytes(d, &baseGroupY, sizeof(baseGroupY)); + uint32_t baseGroupZ; + vkb_dec_bytes(d, &baseGroupZ, sizeof(baseGroupZ)); + uint32_t groupCountX; + vkb_dec_bytes(d, &groupCountX, sizeof(groupCountX)); + uint32_t groupCountY; + vkb_dec_bytes(d, &groupCountY, sizeof(groupCountY)); + uint32_t groupCountZ; + vkb_dec_bytes(d, &groupCountZ, sizeof(groupCountZ)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDispatchBase) { vkb_srv_missing(c, "vkCmdDispatchBase"); return; } + c->dt->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); +} + +void vkb_sv_vkCmdDispatchIndirect(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBuffer buffer; + vkb_dec_bytes(d, &buffer, sizeof(buffer)); + VkDeviceSize offset; + vkb_dec_bytes(d, &offset, sizeof(offset)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDispatchIndirect) { vkb_srv_missing(c, "vkCmdDispatchIndirect"); return; } + c->dt->vkCmdDispatchIndirect(commandBuffer, buffer, offset); +} + +void vkb_sv_vkCmdDraw(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t vertexCount; + vkb_dec_bytes(d, &vertexCount, sizeof(vertexCount)); + uint32_t instanceCount; + vkb_dec_bytes(d, &instanceCount, sizeof(instanceCount)); + uint32_t firstVertex; + vkb_dec_bytes(d, &firstVertex, sizeof(firstVertex)); + uint32_t firstInstance; + vkb_dec_bytes(d, &firstInstance, sizeof(firstInstance)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDraw) { vkb_srv_missing(c, "vkCmdDraw"); return; } + c->dt->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); +} + +void vkb_sv_vkCmdDrawIndexed(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t indexCount; + vkb_dec_bytes(d, &indexCount, sizeof(indexCount)); + uint32_t instanceCount; + vkb_dec_bytes(d, &instanceCount, sizeof(instanceCount)); + uint32_t firstIndex; + vkb_dec_bytes(d, &firstIndex, sizeof(firstIndex)); + int32_t vertexOffset; + vkb_dec_bytes(d, &vertexOffset, sizeof(vertexOffset)); + uint32_t firstInstance; + vkb_dec_bytes(d, &firstInstance, sizeof(firstInstance)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDrawIndexed) { vkb_srv_missing(c, "vkCmdDrawIndexed"); return; } + c->dt->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); +} + +void vkb_sv_vkCmdDrawIndexedIndirect(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBuffer buffer; + vkb_dec_bytes(d, &buffer, sizeof(buffer)); + VkDeviceSize offset; + vkb_dec_bytes(d, &offset, sizeof(offset)); + uint32_t drawCount; + vkb_dec_bytes(d, &drawCount, sizeof(drawCount)); + uint32_t stride; + vkb_dec_bytes(d, &stride, sizeof(stride)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDrawIndexedIndirect) { vkb_srv_missing(c, "vkCmdDrawIndexedIndirect"); return; } + c->dt->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); +} + +void vkb_sv_vkCmdDrawIndexedIndirectCount(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBuffer buffer; + vkb_dec_bytes(d, &buffer, sizeof(buffer)); + VkDeviceSize offset; + vkb_dec_bytes(d, &offset, sizeof(offset)); + VkBuffer countBuffer; + vkb_dec_bytes(d, &countBuffer, sizeof(countBuffer)); + VkDeviceSize countBufferOffset; + vkb_dec_bytes(d, &countBufferOffset, sizeof(countBufferOffset)); + uint32_t maxDrawCount; + vkb_dec_bytes(d, &maxDrawCount, sizeof(maxDrawCount)); + uint32_t stride; + vkb_dec_bytes(d, &stride, sizeof(stride)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDrawIndexedIndirectCount) { vkb_srv_missing(c, "vkCmdDrawIndexedIndirectCount"); return; } + c->dt->vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +void vkb_sv_vkCmdDrawIndirect(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBuffer buffer; + vkb_dec_bytes(d, &buffer, sizeof(buffer)); + VkDeviceSize offset; + vkb_dec_bytes(d, &offset, sizeof(offset)); + uint32_t drawCount; + vkb_dec_bytes(d, &drawCount, sizeof(drawCount)); + uint32_t stride; + vkb_dec_bytes(d, &stride, sizeof(stride)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDrawIndirect) { vkb_srv_missing(c, "vkCmdDrawIndirect"); return; } + c->dt->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); +} + +void vkb_sv_vkCmdDrawIndirectByteCountEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t instanceCount; + vkb_dec_bytes(d, &instanceCount, sizeof(instanceCount)); + uint32_t firstInstance; + vkb_dec_bytes(d, &firstInstance, sizeof(firstInstance)); + VkBuffer counterBuffer; + vkb_dec_bytes(d, &counterBuffer, sizeof(counterBuffer)); + VkDeviceSize counterBufferOffset; + vkb_dec_bytes(d, &counterBufferOffset, sizeof(counterBufferOffset)); + uint32_t counterOffset; + vkb_dec_bytes(d, &counterOffset, sizeof(counterOffset)); + uint32_t vertexStride; + vkb_dec_bytes(d, &vertexStride, sizeof(vertexStride)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDrawIndirectByteCountEXT) { vkb_srv_missing(c, "vkCmdDrawIndirectByteCountEXT"); return; } + c->dt->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); +} + +void vkb_sv_vkCmdDrawIndirectCount(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBuffer buffer; + vkb_dec_bytes(d, &buffer, sizeof(buffer)); + VkDeviceSize offset; + vkb_dec_bytes(d, &offset, sizeof(offset)); + VkBuffer countBuffer; + vkb_dec_bytes(d, &countBuffer, sizeof(countBuffer)); + VkDeviceSize countBufferOffset; + vkb_dec_bytes(d, &countBufferOffset, sizeof(countBufferOffset)); + uint32_t maxDrawCount; + vkb_dec_bytes(d, &maxDrawCount, sizeof(maxDrawCount)); + uint32_t stride; + vkb_dec_bytes(d, &stride, sizeof(stride)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDrawIndirectCount) { vkb_srv_missing(c, "vkCmdDrawIndirectCount"); return; } + c->dt->vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +void vkb_sv_vkCmdDrawMultiEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t drawCount; + vkb_dec_bytes(d, &drawCount, sizeof(drawCount)); + const VkMultiDrawInfoEXT *pVertexInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pVertexInfo = (const VkMultiDrawInfoEXT *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkMultiDrawInfoEXT)); + } else { + pVertexInfo = NULL; + } + uint32_t instanceCount; + vkb_dec_bytes(d, &instanceCount, sizeof(instanceCount)); + uint32_t firstInstance; + vkb_dec_bytes(d, &firstInstance, sizeof(firstInstance)); + uint32_t stride; + vkb_dec_bytes(d, &stride, sizeof(stride)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDrawMultiEXT) { vkb_srv_missing(c, "vkCmdDrawMultiEXT"); return; } + c->dt->vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); +} + +void vkb_sv_vkCmdDrawMultiIndexedEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t drawCount; + vkb_dec_bytes(d, &drawCount, sizeof(drawCount)); + const VkMultiDrawIndexedInfoEXT *pIndexInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pIndexInfo = (const VkMultiDrawIndexedInfoEXT *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkMultiDrawIndexedInfoEXT)); + } else { + pIndexInfo = NULL; + } + uint32_t instanceCount; + vkb_dec_bytes(d, &instanceCount, sizeof(instanceCount)); + uint32_t firstInstance; + vkb_dec_bytes(d, &firstInstance, sizeof(firstInstance)); + uint32_t stride; + vkb_dec_bytes(d, &stride, sizeof(stride)); + const int32_t *pVertexOffset; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pVertexOffset = (const int32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(int32_t)); + } else { + pVertexOffset = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdDrawMultiIndexedEXT) { vkb_srv_missing(c, "vkCmdDrawMultiIndexedEXT"); return; } + c->dt->vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); +} + +void vkb_sv_vkCmdEndConditionalRenderingEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdEndConditionalRenderingEXT) { vkb_srv_missing(c, "vkCmdEndConditionalRenderingEXT"); return; } + c->dt->vkCmdEndConditionalRenderingEXT(commandBuffer); +} + +void vkb_sv_vkCmdEndQuery(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkQueryPool queryPool; + vkb_dec_bytes(d, &queryPool, sizeof(queryPool)); + uint32_t query; + vkb_dec_bytes(d, &query, sizeof(query)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdEndQuery) { vkb_srv_missing(c, "vkCmdEndQuery"); return; } + c->dt->vkCmdEndQuery(commandBuffer, queryPool, query); +} + +void vkb_sv_vkCmdEndQueryIndexedEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkQueryPool queryPool; + vkb_dec_bytes(d, &queryPool, sizeof(queryPool)); + uint32_t query; + vkb_dec_bytes(d, &query, sizeof(query)); + uint32_t index; + vkb_dec_bytes(d, &index, sizeof(index)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdEndQueryIndexedEXT) { vkb_srv_missing(c, "vkCmdEndQueryIndexedEXT"); return; } + c->dt->vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); +} + +void vkb_sv_vkCmdEndRenderPass(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdEndRenderPass) { vkb_srv_missing(c, "vkCmdEndRenderPass"); return; } + c->dt->vkCmdEndRenderPass(commandBuffer); +} + +void vkb_sv_vkCmdEndRenderPass2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkSubpassEndInfo *pSubpassEndInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSubpassEndInfo *a_ = (VkSubpassEndInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSubpassEndInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSubpassEndInfo(d, &a_[i_]); + pSubpassEndInfo = a_; + } else { + pSubpassEndInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdEndRenderPass2) { vkb_srv_missing(c, "vkCmdEndRenderPass2"); return; } + c->dt->vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo); +} + +void vkb_sv_vkCmdEndRendering(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdEndRendering) { vkb_srv_missing(c, "vkCmdEndRendering"); return; } + c->dt->vkCmdEndRendering(commandBuffer); +} + +void vkb_sv_vkCmdEndTransformFeedbackEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstCounterBuffer; + vkb_dec_bytes(d, &firstCounterBuffer, sizeof(firstCounterBuffer)); + uint32_t counterBufferCount; + vkb_dec_bytes(d, &counterBufferCount, sizeof(counterBufferCount)); + const VkBuffer *pCounterBuffers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pCounterBuffers = (const VkBuffer *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBuffer)); + } else { + pCounterBuffers = NULL; + } + const VkDeviceSize *pCounterBufferOffsets; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pCounterBufferOffsets = (const VkDeviceSize *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDeviceSize)); + } else { + pCounterBufferOffsets = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdEndTransformFeedbackEXT) { vkb_srv_missing(c, "vkCmdEndTransformFeedbackEXT"); return; } + c->dt->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); +} + +void vkb_sv_vkCmdExecuteCommands(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t commandBufferCount; + vkb_dec_bytes(d, &commandBufferCount, sizeof(commandBufferCount)); + const VkCommandBuffer *pCommandBuffers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCommandBuffer *a_ = (VkCommandBuffer *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCommandBuffer)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) a_[i_] = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + pCommandBuffers = a_; + } else { + pCommandBuffers = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdExecuteCommands) { vkb_srv_missing(c, "vkCmdExecuteCommands"); return; } + c->dt->vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); +} + +void vkb_sv_vkCmdFillBuffer(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBuffer dstBuffer; + vkb_dec_bytes(d, &dstBuffer, sizeof(dstBuffer)); + VkDeviceSize dstOffset; + vkb_dec_bytes(d, &dstOffset, sizeof(dstOffset)); + VkDeviceSize size; + vkb_dec_bytes(d, &size, sizeof(size)); + uint32_t data; + vkb_dec_bytes(d, &data, sizeof(data)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdFillBuffer) { vkb_srv_missing(c, "vkCmdFillBuffer"); return; } + c->dt->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); +} + +void vkb_sv_vkCmdNextSubpass(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkSubpassContents contents; + vkb_dec_bytes(d, &contents, sizeof(contents)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdNextSubpass) { vkb_srv_missing(c, "vkCmdNextSubpass"); return; } + c->dt->vkCmdNextSubpass(commandBuffer, contents); +} + +void vkb_sv_vkCmdNextSubpass2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkSubpassBeginInfo *pSubpassBeginInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSubpassBeginInfo *a_ = (VkSubpassBeginInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSubpassBeginInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSubpassBeginInfo(d, &a_[i_]); + pSubpassBeginInfo = a_; + } else { + pSubpassBeginInfo = NULL; + } + const VkSubpassEndInfo *pSubpassEndInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSubpassEndInfo *a_ = (VkSubpassEndInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSubpassEndInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSubpassEndInfo(d, &a_[i_]); + pSubpassEndInfo = a_; + } else { + pSubpassEndInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdNextSubpass2) { vkb_srv_missing(c, "vkCmdNextSubpass2"); return; } + c->dt->vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); +} + +void vkb_sv_vkCmdPipelineBarrier(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkPipelineStageFlags srcStageMask; + vkb_dec_bytes(d, &srcStageMask, sizeof(srcStageMask)); + VkPipelineStageFlags dstStageMask; + vkb_dec_bytes(d, &dstStageMask, sizeof(dstStageMask)); + VkDependencyFlags dependencyFlags; + vkb_dec_bytes(d, &dependencyFlags, sizeof(dependencyFlags)); + uint32_t memoryBarrierCount; + vkb_dec_bytes(d, &memoryBarrierCount, sizeof(memoryBarrierCount)); + const VkMemoryBarrier *pMemoryBarriers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkMemoryBarrier *a_ = (VkMemoryBarrier *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkMemoryBarrier)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkMemoryBarrier(d, &a_[i_]); + pMemoryBarriers = a_; + } else { + pMemoryBarriers = NULL; + } + uint32_t bufferMemoryBarrierCount; + vkb_dec_bytes(d, &bufferMemoryBarrierCount, sizeof(bufferMemoryBarrierCount)); + const VkBufferMemoryBarrier *pBufferMemoryBarriers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferMemoryBarrier *a_ = (VkBufferMemoryBarrier *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferMemoryBarrier)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferMemoryBarrier(d, &a_[i_]); + pBufferMemoryBarriers = a_; + } else { + pBufferMemoryBarriers = NULL; + } + uint32_t imageMemoryBarrierCount; + vkb_dec_bytes(d, &imageMemoryBarrierCount, sizeof(imageMemoryBarrierCount)); + const VkImageMemoryBarrier *pImageMemoryBarriers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageMemoryBarrier *a_ = (VkImageMemoryBarrier *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageMemoryBarrier)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageMemoryBarrier(d, &a_[i_]); + pImageMemoryBarriers = a_; + } else { + pImageMemoryBarriers = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdPipelineBarrier) { vkb_srv_missing(c, "vkCmdPipelineBarrier"); return; } + c->dt->vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); +} + +void vkb_sv_vkCmdPipelineBarrier2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkDependencyInfo *pDependencyInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDependencyInfo *a_ = (VkDependencyInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDependencyInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDependencyInfo(d, &a_[i_]); + pDependencyInfo = a_; + } else { + pDependencyInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdPipelineBarrier2) { vkb_srv_missing(c, "vkCmdPipelineBarrier2"); return; } + c->dt->vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo); +} + +void vkb_sv_vkCmdPushConstants(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkPipelineLayout layout; + vkb_dec_bytes(d, &layout, sizeof(layout)); + VkShaderStageFlags stageFlags; + vkb_dec_bytes(d, &stageFlags, sizeof(stageFlags)); + uint32_t offset; + vkb_dec_bytes(d, &offset, sizeof(offset)); + uint32_t size; + vkb_dec_bytes(d, &size, sizeof(size)); + const void *pValues; + pValues = (const void *)vkb_dec_blob(d, NULL); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdPushConstants) { vkb_srv_missing(c, "vkCmdPushConstants"); return; } + c->dt->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); +} + +void vkb_sv_vkCmdPushDescriptorSetKHR(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkPipelineBindPoint pipelineBindPoint; + vkb_dec_bytes(d, &pipelineBindPoint, sizeof(pipelineBindPoint)); + VkPipelineLayout layout; + vkb_dec_bytes(d, &layout, sizeof(layout)); + uint32_t set; + vkb_dec_bytes(d, &set, sizeof(set)); + uint32_t descriptorWriteCount; + vkb_dec_bytes(d, &descriptorWriteCount, sizeof(descriptorWriteCount)); + const VkWriteDescriptorSet *pDescriptorWrites; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkWriteDescriptorSet *a_ = (VkWriteDescriptorSet *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkWriteDescriptorSet)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkWriteDescriptorSet(d, &a_[i_]); + pDescriptorWrites = a_; + } else { + pDescriptorWrites = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdPushDescriptorSetKHR) { vkb_srv_missing(c, "vkCmdPushDescriptorSetKHR"); return; } + c->dt->vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); +} + +void vkb_sv_vkCmdResetEvent(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkEvent event; + vkb_dec_bytes(d, &event, sizeof(event)); + VkPipelineStageFlags stageMask; + vkb_dec_bytes(d, &stageMask, sizeof(stageMask)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdResetEvent) { vkb_srv_missing(c, "vkCmdResetEvent"); return; } + c->dt->vkCmdResetEvent(commandBuffer, event, stageMask); +} + +void vkb_sv_vkCmdResetEvent2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkEvent event; + vkb_dec_bytes(d, &event, sizeof(event)); + VkPipelineStageFlags2 stageMask; + vkb_dec_bytes(d, &stageMask, sizeof(stageMask)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdResetEvent2) { vkb_srv_missing(c, "vkCmdResetEvent2"); return; } + c->dt->vkCmdResetEvent2(commandBuffer, event, stageMask); +} + +void vkb_sv_vkCmdResetQueryPool(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkQueryPool queryPool; + vkb_dec_bytes(d, &queryPool, sizeof(queryPool)); + uint32_t firstQuery; + vkb_dec_bytes(d, &firstQuery, sizeof(firstQuery)); + uint32_t queryCount; + vkb_dec_bytes(d, &queryCount, sizeof(queryCount)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdResetQueryPool) { vkb_srv_missing(c, "vkCmdResetQueryPool"); return; } + c->dt->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); +} + +void vkb_sv_vkCmdResolveImage(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkImage srcImage; + vkb_dec_bytes(d, &srcImage, sizeof(srcImage)); + VkImageLayout srcImageLayout; + vkb_dec_bytes(d, &srcImageLayout, sizeof(srcImageLayout)); + VkImage dstImage; + vkb_dec_bytes(d, &dstImage, sizeof(dstImage)); + VkImageLayout dstImageLayout; + vkb_dec_bytes(d, &dstImageLayout, sizeof(dstImageLayout)); + uint32_t regionCount; + vkb_dec_bytes(d, ®ionCount, sizeof(regionCount)); + const VkImageResolve *pRegions; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pRegions = (const VkImageResolve *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkImageResolve)); + } else { + pRegions = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdResolveImage) { vkb_srv_missing(c, "vkCmdResolveImage"); return; } + c->dt->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); +} + +void vkb_sv_vkCmdResolveImage2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkResolveImageInfo2 *pResolveImageInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkResolveImageInfo2 *a_ = (VkResolveImageInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkResolveImageInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkResolveImageInfo2(d, &a_[i_]); + pResolveImageInfo = a_; + } else { + pResolveImageInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdResolveImage2) { vkb_srv_missing(c, "vkCmdResolveImage2"); return; } + c->dt->vkCmdResolveImage2(commandBuffer, pResolveImageInfo); +} + +void vkb_sv_vkCmdSetAlphaToCoverageEnableEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 alphaToCoverageEnable; + vkb_dec_bytes(d, &alphaToCoverageEnable, sizeof(alphaToCoverageEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetAlphaToCoverageEnableEXT) { vkb_srv_missing(c, "vkCmdSetAlphaToCoverageEnableEXT"); return; } + c->dt->vkCmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable); +} + +void vkb_sv_vkCmdSetAlphaToOneEnableEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 alphaToOneEnable; + vkb_dec_bytes(d, &alphaToOneEnable, sizeof(alphaToOneEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetAlphaToOneEnableEXT) { vkb_srv_missing(c, "vkCmdSetAlphaToOneEnableEXT"); return; } + c->dt->vkCmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable); +} + +void vkb_sv_vkCmdSetBlendConstants(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const float *blendConstants = (const float *)vkb_dec_raw_view(d, sizeof(float) * 4); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetBlendConstants) { vkb_srv_missing(c, "vkCmdSetBlendConstants"); return; } + c->dt->vkCmdSetBlendConstants(commandBuffer, blendConstants); +} + +void vkb_sv_vkCmdSetColorBlendAdvancedEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstAttachment; + vkb_dec_bytes(d, &firstAttachment, sizeof(firstAttachment)); + uint32_t attachmentCount; + vkb_dec_bytes(d, &attachmentCount, sizeof(attachmentCount)); + const VkColorBlendAdvancedEXT *pColorBlendAdvanced; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pColorBlendAdvanced = (const VkColorBlendAdvancedEXT *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkColorBlendAdvancedEXT)); + } else { + pColorBlendAdvanced = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetColorBlendAdvancedEXT) { vkb_srv_missing(c, "vkCmdSetColorBlendAdvancedEXT"); return; } + c->dt->vkCmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); +} + +void vkb_sv_vkCmdSetColorBlendEnableEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstAttachment; + vkb_dec_bytes(d, &firstAttachment, sizeof(firstAttachment)); + uint32_t attachmentCount; + vkb_dec_bytes(d, &attachmentCount, sizeof(attachmentCount)); + const VkBool32 *pColorBlendEnables; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pColorBlendEnables = (const VkBool32 *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBool32)); + } else { + pColorBlendEnables = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetColorBlendEnableEXT) { vkb_srv_missing(c, "vkCmdSetColorBlendEnableEXT"); return; } + c->dt->vkCmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); +} + +void vkb_sv_vkCmdSetColorBlendEquationEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstAttachment; + vkb_dec_bytes(d, &firstAttachment, sizeof(firstAttachment)); + uint32_t attachmentCount; + vkb_dec_bytes(d, &attachmentCount, sizeof(attachmentCount)); + const VkColorBlendEquationEXT *pColorBlendEquations; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pColorBlendEquations = (const VkColorBlendEquationEXT *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkColorBlendEquationEXT)); + } else { + pColorBlendEquations = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetColorBlendEquationEXT) { vkb_srv_missing(c, "vkCmdSetColorBlendEquationEXT"); return; } + c->dt->vkCmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); +} + +void vkb_sv_vkCmdSetColorWriteEnableEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t attachmentCount; + vkb_dec_bytes(d, &attachmentCount, sizeof(attachmentCount)); + const VkBool32 *pColorWriteEnables; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pColorWriteEnables = (const VkBool32 *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBool32)); + } else { + pColorWriteEnables = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetColorWriteEnableEXT) { vkb_srv_missing(c, "vkCmdSetColorWriteEnableEXT"); return; } + c->dt->vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); +} + +void vkb_sv_vkCmdSetColorWriteMaskEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstAttachment; + vkb_dec_bytes(d, &firstAttachment, sizeof(firstAttachment)); + uint32_t attachmentCount; + vkb_dec_bytes(d, &attachmentCount, sizeof(attachmentCount)); + const VkColorComponentFlags *pColorWriteMasks; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pColorWriteMasks = (const VkColorComponentFlags *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkColorComponentFlags)); + } else { + pColorWriteMasks = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetColorWriteMaskEXT) { vkb_srv_missing(c, "vkCmdSetColorWriteMaskEXT"); return; } + c->dt->vkCmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); +} + +void vkb_sv_vkCmdSetConservativeRasterizationModeEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + vkb_dec_bytes(d, &conservativeRasterizationMode, sizeof(conservativeRasterizationMode)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetConservativeRasterizationModeEXT) { vkb_srv_missing(c, "vkCmdSetConservativeRasterizationModeEXT"); return; } + c->dt->vkCmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode); +} + +void vkb_sv_vkCmdSetCoverageModulationModeNV(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkCoverageModulationModeNV coverageModulationMode; + vkb_dec_bytes(d, &coverageModulationMode, sizeof(coverageModulationMode)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetCoverageModulationModeNV) { vkb_srv_missing(c, "vkCmdSetCoverageModulationModeNV"); return; } + c->dt->vkCmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode); +} + +void vkb_sv_vkCmdSetCoverageModulationTableEnableNV(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 coverageModulationTableEnable; + vkb_dec_bytes(d, &coverageModulationTableEnable, sizeof(coverageModulationTableEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetCoverageModulationTableEnableNV) { vkb_srv_missing(c, "vkCmdSetCoverageModulationTableEnableNV"); return; } + c->dt->vkCmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable); +} + +void vkb_sv_vkCmdSetCoverageModulationTableNV(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t coverageModulationTableCount; + vkb_dec_bytes(d, &coverageModulationTableCount, sizeof(coverageModulationTableCount)); + const float *pCoverageModulationTable; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pCoverageModulationTable = (const float *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(float)); + } else { + pCoverageModulationTable = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetCoverageModulationTableNV) { vkb_srv_missing(c, "vkCmdSetCoverageModulationTableNV"); return; } + c->dt->vkCmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable); +} + +void vkb_sv_vkCmdSetCoverageReductionModeNV(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkCoverageReductionModeNV coverageReductionMode; + vkb_dec_bytes(d, &coverageReductionMode, sizeof(coverageReductionMode)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetCoverageReductionModeNV) { vkb_srv_missing(c, "vkCmdSetCoverageReductionModeNV"); return; } + c->dt->vkCmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode); +} + +void vkb_sv_vkCmdSetCoverageToColorEnableNV(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 coverageToColorEnable; + vkb_dec_bytes(d, &coverageToColorEnable, sizeof(coverageToColorEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetCoverageToColorEnableNV) { vkb_srv_missing(c, "vkCmdSetCoverageToColorEnableNV"); return; } + c->dt->vkCmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable); +} + +void vkb_sv_vkCmdSetCoverageToColorLocationNV(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t coverageToColorLocation; + vkb_dec_bytes(d, &coverageToColorLocation, sizeof(coverageToColorLocation)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetCoverageToColorLocationNV) { vkb_srv_missing(c, "vkCmdSetCoverageToColorLocationNV"); return; } + c->dt->vkCmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation); +} + +void vkb_sv_vkCmdSetCullMode(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkCullModeFlags cullMode; + vkb_dec_bytes(d, &cullMode, sizeof(cullMode)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetCullMode) { vkb_srv_missing(c, "vkCmdSetCullMode"); return; } + c->dt->vkCmdSetCullMode(commandBuffer, cullMode); +} + +void vkb_sv_vkCmdSetDepthBias(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + float depthBiasConstantFactor; + vkb_dec_bytes(d, &depthBiasConstantFactor, sizeof(depthBiasConstantFactor)); + float depthBiasClamp; + vkb_dec_bytes(d, &depthBiasClamp, sizeof(depthBiasClamp)); + float depthBiasSlopeFactor; + vkb_dec_bytes(d, &depthBiasSlopeFactor, sizeof(depthBiasSlopeFactor)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDepthBias) { vkb_srv_missing(c, "vkCmdSetDepthBias"); return; } + c->dt->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); +} + +void vkb_sv_vkCmdSetDepthBiasEnable(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 depthBiasEnable; + vkb_dec_bytes(d, &depthBiasEnable, sizeof(depthBiasEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDepthBiasEnable) { vkb_srv_missing(c, "vkCmdSetDepthBiasEnable"); return; } + c->dt->vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); +} + +void vkb_sv_vkCmdSetDepthBounds(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + float minDepthBounds; + vkb_dec_bytes(d, &minDepthBounds, sizeof(minDepthBounds)); + float maxDepthBounds; + vkb_dec_bytes(d, &maxDepthBounds, sizeof(maxDepthBounds)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDepthBounds) { vkb_srv_missing(c, "vkCmdSetDepthBounds"); return; } + c->dt->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); +} + +void vkb_sv_vkCmdSetDepthBoundsTestEnable(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 depthBoundsTestEnable; + vkb_dec_bytes(d, &depthBoundsTestEnable, sizeof(depthBoundsTestEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDepthBoundsTestEnable) { vkb_srv_missing(c, "vkCmdSetDepthBoundsTestEnable"); return; } + c->dt->vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); +} + +void vkb_sv_vkCmdSetDepthClampEnableEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 depthClampEnable; + vkb_dec_bytes(d, &depthClampEnable, sizeof(depthClampEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDepthClampEnableEXT) { vkb_srv_missing(c, "vkCmdSetDepthClampEnableEXT"); return; } + c->dt->vkCmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable); +} + +void vkb_sv_vkCmdSetDepthClipEnableEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 depthClipEnable; + vkb_dec_bytes(d, &depthClipEnable, sizeof(depthClipEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDepthClipEnableEXT) { vkb_srv_missing(c, "vkCmdSetDepthClipEnableEXT"); return; } + c->dt->vkCmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable); +} + +void vkb_sv_vkCmdSetDepthClipNegativeOneToOneEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 negativeOneToOne; + vkb_dec_bytes(d, &negativeOneToOne, sizeof(negativeOneToOne)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDepthClipNegativeOneToOneEXT) { vkb_srv_missing(c, "vkCmdSetDepthClipNegativeOneToOneEXT"); return; } + c->dt->vkCmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne); +} + +void vkb_sv_vkCmdSetDepthCompareOp(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkCompareOp depthCompareOp; + vkb_dec_bytes(d, &depthCompareOp, sizeof(depthCompareOp)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDepthCompareOp) { vkb_srv_missing(c, "vkCmdSetDepthCompareOp"); return; } + c->dt->vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp); +} + +void vkb_sv_vkCmdSetDepthTestEnable(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 depthTestEnable; + vkb_dec_bytes(d, &depthTestEnable, sizeof(depthTestEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDepthTestEnable) { vkb_srv_missing(c, "vkCmdSetDepthTestEnable"); return; } + c->dt->vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable); +} + +void vkb_sv_vkCmdSetDepthWriteEnable(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 depthWriteEnable; + vkb_dec_bytes(d, &depthWriteEnable, sizeof(depthWriteEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDepthWriteEnable) { vkb_srv_missing(c, "vkCmdSetDepthWriteEnable"); return; } + c->dt->vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); +} + +void vkb_sv_vkCmdSetDeviceMask(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t deviceMask; + vkb_dec_bytes(d, &deviceMask, sizeof(deviceMask)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDeviceMask) { vkb_srv_missing(c, "vkCmdSetDeviceMask"); return; } + c->dt->vkCmdSetDeviceMask(commandBuffer, deviceMask); +} + +void vkb_sv_vkCmdSetDiscardRectangleEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstDiscardRectangle; + vkb_dec_bytes(d, &firstDiscardRectangle, sizeof(firstDiscardRectangle)); + uint32_t discardRectangleCount; + vkb_dec_bytes(d, &discardRectangleCount, sizeof(discardRectangleCount)); + const VkRect2D *pDiscardRectangles; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pDiscardRectangles = (const VkRect2D *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkRect2D)); + } else { + pDiscardRectangles = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDiscardRectangleEXT) { vkb_srv_missing(c, "vkCmdSetDiscardRectangleEXT"); return; } + c->dt->vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); +} + +void vkb_sv_vkCmdSetDiscardRectangleEnableEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 discardRectangleEnable; + vkb_dec_bytes(d, &discardRectangleEnable, sizeof(discardRectangleEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDiscardRectangleEnableEXT) { vkb_srv_missing(c, "vkCmdSetDiscardRectangleEnableEXT"); return; } + c->dt->vkCmdSetDiscardRectangleEnableEXT(commandBuffer, discardRectangleEnable); +} + +void vkb_sv_vkCmdSetDiscardRectangleModeEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkDiscardRectangleModeEXT discardRectangleMode; + vkb_dec_bytes(d, &discardRectangleMode, sizeof(discardRectangleMode)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetDiscardRectangleModeEXT) { vkb_srv_missing(c, "vkCmdSetDiscardRectangleModeEXT"); return; } + c->dt->vkCmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode); +} + +void vkb_sv_vkCmdSetEvent(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkEvent event; + vkb_dec_bytes(d, &event, sizeof(event)); + VkPipelineStageFlags stageMask; + vkb_dec_bytes(d, &stageMask, sizeof(stageMask)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetEvent) { vkb_srv_missing(c, "vkCmdSetEvent"); return; } + c->dt->vkCmdSetEvent(commandBuffer, event, stageMask); +} + +void vkb_sv_vkCmdSetEvent2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkEvent event; + vkb_dec_bytes(d, &event, sizeof(event)); + const VkDependencyInfo *pDependencyInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDependencyInfo *a_ = (VkDependencyInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDependencyInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDependencyInfo(d, &a_[i_]); + pDependencyInfo = a_; + } else { + pDependencyInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetEvent2) { vkb_srv_missing(c, "vkCmdSetEvent2"); return; } + c->dt->vkCmdSetEvent2(commandBuffer, event, pDependencyInfo); +} + +void vkb_sv_vkCmdSetExtraPrimitiveOverestimationSizeEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + float extraPrimitiveOverestimationSize; + vkb_dec_bytes(d, &extraPrimitiveOverestimationSize, sizeof(extraPrimitiveOverestimationSize)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetExtraPrimitiveOverestimationSizeEXT) { vkb_srv_missing(c, "vkCmdSetExtraPrimitiveOverestimationSizeEXT"); return; } + c->dt->vkCmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize); +} + +void vkb_sv_vkCmdSetFragmentShadingRateKHR(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkExtent2D *pFragmentSize; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pFragmentSize = (const VkExtent2D *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkExtent2D)); + } else { + pFragmentSize = NULL; + } + const VkFragmentShadingRateCombinerOpKHR *combinerOps = (const VkFragmentShadingRateCombinerOpKHR *)vkb_dec_raw_view(d, sizeof(VkFragmentShadingRateCombinerOpKHR) * 2); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetFragmentShadingRateKHR) { vkb_srv_missing(c, "vkCmdSetFragmentShadingRateKHR"); return; } + c->dt->vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); +} + +void vkb_sv_vkCmdSetFrontFace(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkFrontFace frontFace; + vkb_dec_bytes(d, &frontFace, sizeof(frontFace)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetFrontFace) { vkb_srv_missing(c, "vkCmdSetFrontFace"); return; } + c->dt->vkCmdSetFrontFace(commandBuffer, frontFace); +} + +void vkb_sv_vkCmdSetLineRasterizationModeEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkLineRasterizationModeEXT lineRasterizationMode; + vkb_dec_bytes(d, &lineRasterizationMode, sizeof(lineRasterizationMode)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetLineRasterizationModeEXT) { vkb_srv_missing(c, "vkCmdSetLineRasterizationModeEXT"); return; } + c->dt->vkCmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode); +} + +void vkb_sv_vkCmdSetLineStippleEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t lineStippleFactor; + vkb_dec_bytes(d, &lineStippleFactor, sizeof(lineStippleFactor)); + uint16_t lineStipplePattern; + vkb_dec_bytes(d, &lineStipplePattern, sizeof(lineStipplePattern)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetLineStippleEXT) { vkb_srv_missing(c, "vkCmdSetLineStippleEXT"); return; } + c->dt->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); +} + +void vkb_sv_vkCmdSetLineStippleEnableEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 stippledLineEnable; + vkb_dec_bytes(d, &stippledLineEnable, sizeof(stippledLineEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetLineStippleEnableEXT) { vkb_srv_missing(c, "vkCmdSetLineStippleEnableEXT"); return; } + c->dt->vkCmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable); +} + +void vkb_sv_vkCmdSetLineWidth(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + float lineWidth; + vkb_dec_bytes(d, &lineWidth, sizeof(lineWidth)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetLineWidth) { vkb_srv_missing(c, "vkCmdSetLineWidth"); return; } + c->dt->vkCmdSetLineWidth(commandBuffer, lineWidth); +} + +void vkb_sv_vkCmdSetLogicOpEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkLogicOp logicOp; + vkb_dec_bytes(d, &logicOp, sizeof(logicOp)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetLogicOpEXT) { vkb_srv_missing(c, "vkCmdSetLogicOpEXT"); return; } + c->dt->vkCmdSetLogicOpEXT(commandBuffer, logicOp); +} + +void vkb_sv_vkCmdSetLogicOpEnableEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 logicOpEnable; + vkb_dec_bytes(d, &logicOpEnable, sizeof(logicOpEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetLogicOpEnableEXT) { vkb_srv_missing(c, "vkCmdSetLogicOpEnableEXT"); return; } + c->dt->vkCmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable); +} + +void vkb_sv_vkCmdSetPatchControlPointsEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t patchControlPoints; + vkb_dec_bytes(d, &patchControlPoints, sizeof(patchControlPoints)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetPatchControlPointsEXT) { vkb_srv_missing(c, "vkCmdSetPatchControlPointsEXT"); return; } + c->dt->vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); +} + +void vkb_sv_vkCmdSetPolygonModeEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkPolygonMode polygonMode; + vkb_dec_bytes(d, &polygonMode, sizeof(polygonMode)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetPolygonModeEXT) { vkb_srv_missing(c, "vkCmdSetPolygonModeEXT"); return; } + c->dt->vkCmdSetPolygonModeEXT(commandBuffer, polygonMode); +} + +void vkb_sv_vkCmdSetPrimitiveRestartEnable(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 primitiveRestartEnable; + vkb_dec_bytes(d, &primitiveRestartEnable, sizeof(primitiveRestartEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetPrimitiveRestartEnable) { vkb_srv_missing(c, "vkCmdSetPrimitiveRestartEnable"); return; } + c->dt->vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); +} + +void vkb_sv_vkCmdSetPrimitiveTopology(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkPrimitiveTopology primitiveTopology; + vkb_dec_bytes(d, &primitiveTopology, sizeof(primitiveTopology)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetPrimitiveTopology) { vkb_srv_missing(c, "vkCmdSetPrimitiveTopology"); return; } + c->dt->vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology); +} + +void vkb_sv_vkCmdSetProvokingVertexModeEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkProvokingVertexModeEXT provokingVertexMode; + vkb_dec_bytes(d, &provokingVertexMode, sizeof(provokingVertexMode)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetProvokingVertexModeEXT) { vkb_srv_missing(c, "vkCmdSetProvokingVertexModeEXT"); return; } + c->dt->vkCmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode); +} + +void vkb_sv_vkCmdSetRasterizationSamplesEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkSampleCountFlagBits rasterizationSamples; + vkb_dec_bytes(d, &rasterizationSamples, sizeof(rasterizationSamples)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetRasterizationSamplesEXT) { vkb_srv_missing(c, "vkCmdSetRasterizationSamplesEXT"); return; } + c->dt->vkCmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples); +} + +void vkb_sv_vkCmdSetRasterizationStreamEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t rasterizationStream; + vkb_dec_bytes(d, &rasterizationStream, sizeof(rasterizationStream)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetRasterizationStreamEXT) { vkb_srv_missing(c, "vkCmdSetRasterizationStreamEXT"); return; } + c->dt->vkCmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream); +} + +void vkb_sv_vkCmdSetRasterizerDiscardEnable(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 rasterizerDiscardEnable; + vkb_dec_bytes(d, &rasterizerDiscardEnable, sizeof(rasterizerDiscardEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetRasterizerDiscardEnable) { vkb_srv_missing(c, "vkCmdSetRasterizerDiscardEnable"); return; } + c->dt->vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); +} + +void vkb_sv_vkCmdSetRepresentativeFragmentTestEnableNV(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 representativeFragmentTestEnable; + vkb_dec_bytes(d, &representativeFragmentTestEnable, sizeof(representativeFragmentTestEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetRepresentativeFragmentTestEnableNV) { vkb_srv_missing(c, "vkCmdSetRepresentativeFragmentTestEnableNV"); return; } + c->dt->vkCmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable); +} + +void vkb_sv_vkCmdSetSampleLocationsEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + const VkSampleLocationsInfoEXT *pSampleLocationsInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSampleLocationsInfoEXT *a_ = (VkSampleLocationsInfoEXT *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSampleLocationsInfoEXT)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSampleLocationsInfoEXT(d, &a_[i_]); + pSampleLocationsInfo = a_; + } else { + pSampleLocationsInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetSampleLocationsEXT) { vkb_srv_missing(c, "vkCmdSetSampleLocationsEXT"); return; } + c->dt->vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); +} + +void vkb_sv_vkCmdSetSampleLocationsEnableEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 sampleLocationsEnable; + vkb_dec_bytes(d, &sampleLocationsEnable, sizeof(sampleLocationsEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetSampleLocationsEnableEXT) { vkb_srv_missing(c, "vkCmdSetSampleLocationsEnableEXT"); return; } + c->dt->vkCmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable); +} + +void vkb_sv_vkCmdSetSampleMaskEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkSampleCountFlagBits samples; + vkb_dec_bytes(d, &samples, sizeof(samples)); + const VkSampleMask *pSampleMask; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pSampleMask = (const VkSampleMask *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSampleMask)); + } else { + pSampleMask = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetSampleMaskEXT) { vkb_srv_missing(c, "vkCmdSetSampleMaskEXT"); return; } + c->dt->vkCmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask); +} + +void vkb_sv_vkCmdSetScissor(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstScissor; + vkb_dec_bytes(d, &firstScissor, sizeof(firstScissor)); + uint32_t scissorCount; + vkb_dec_bytes(d, &scissorCount, sizeof(scissorCount)); + const VkRect2D *pScissors; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pScissors = (const VkRect2D *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkRect2D)); + } else { + pScissors = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetScissor) { vkb_srv_missing(c, "vkCmdSetScissor"); return; } + c->dt->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); +} + +void vkb_sv_vkCmdSetScissorWithCount(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t scissorCount; + vkb_dec_bytes(d, &scissorCount, sizeof(scissorCount)); + const VkRect2D *pScissors; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pScissors = (const VkRect2D *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkRect2D)); + } else { + pScissors = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetScissorWithCount) { vkb_srv_missing(c, "vkCmdSetScissorWithCount"); return; } + c->dt->vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); +} + +void vkb_sv_vkCmdSetShadingRateImageEnableNV(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 shadingRateImageEnable; + vkb_dec_bytes(d, &shadingRateImageEnable, sizeof(shadingRateImageEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetShadingRateImageEnableNV) { vkb_srv_missing(c, "vkCmdSetShadingRateImageEnableNV"); return; } + c->dt->vkCmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable); +} + +void vkb_sv_vkCmdSetStencilCompareMask(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkStencilFaceFlags faceMask; + vkb_dec_bytes(d, &faceMask, sizeof(faceMask)); + uint32_t compareMask; + vkb_dec_bytes(d, &compareMask, sizeof(compareMask)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetStencilCompareMask) { vkb_srv_missing(c, "vkCmdSetStencilCompareMask"); return; } + c->dt->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); +} + +void vkb_sv_vkCmdSetStencilOp(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkStencilFaceFlags faceMask; + vkb_dec_bytes(d, &faceMask, sizeof(faceMask)); + VkStencilOp failOp; + vkb_dec_bytes(d, &failOp, sizeof(failOp)); + VkStencilOp passOp; + vkb_dec_bytes(d, &passOp, sizeof(passOp)); + VkStencilOp depthFailOp; + vkb_dec_bytes(d, &depthFailOp, sizeof(depthFailOp)); + VkCompareOp compareOp; + vkb_dec_bytes(d, &compareOp, sizeof(compareOp)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetStencilOp) { vkb_srv_missing(c, "vkCmdSetStencilOp"); return; } + c->dt->vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); +} + +void vkb_sv_vkCmdSetStencilReference(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkStencilFaceFlags faceMask; + vkb_dec_bytes(d, &faceMask, sizeof(faceMask)); + uint32_t reference; + vkb_dec_bytes(d, &reference, sizeof(reference)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetStencilReference) { vkb_srv_missing(c, "vkCmdSetStencilReference"); return; } + c->dt->vkCmdSetStencilReference(commandBuffer, faceMask, reference); +} + +void vkb_sv_vkCmdSetStencilTestEnable(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 stencilTestEnable; + vkb_dec_bytes(d, &stencilTestEnable, sizeof(stencilTestEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetStencilTestEnable) { vkb_srv_missing(c, "vkCmdSetStencilTestEnable"); return; } + c->dt->vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable); +} + +void vkb_sv_vkCmdSetStencilWriteMask(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkStencilFaceFlags faceMask; + vkb_dec_bytes(d, &faceMask, sizeof(faceMask)); + uint32_t writeMask; + vkb_dec_bytes(d, &writeMask, sizeof(writeMask)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetStencilWriteMask) { vkb_srv_missing(c, "vkCmdSetStencilWriteMask"); return; } + c->dt->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); +} + +void vkb_sv_vkCmdSetTessellationDomainOriginEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkTessellationDomainOrigin domainOrigin; + vkb_dec_bytes(d, &domainOrigin, sizeof(domainOrigin)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetTessellationDomainOriginEXT) { vkb_srv_missing(c, "vkCmdSetTessellationDomainOriginEXT"); return; } + c->dt->vkCmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin); +} + +void vkb_sv_vkCmdSetVertexInputEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t vertexBindingDescriptionCount; + vkb_dec_bytes(d, &vertexBindingDescriptionCount, sizeof(vertexBindingDescriptionCount)); + const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkVertexInputBindingDescription2EXT *a_ = (VkVertexInputBindingDescription2EXT *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkVertexInputBindingDescription2EXT)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkVertexInputBindingDescription2EXT(d, &a_[i_]); + pVertexBindingDescriptions = a_; + } else { + pVertexBindingDescriptions = NULL; + } + uint32_t vertexAttributeDescriptionCount; + vkb_dec_bytes(d, &vertexAttributeDescriptionCount, sizeof(vertexAttributeDescriptionCount)); + const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkVertexInputAttributeDescription2EXT *a_ = (VkVertexInputAttributeDescription2EXT *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkVertexInputAttributeDescription2EXT)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkVertexInputAttributeDescription2EXT(d, &a_[i_]); + pVertexAttributeDescriptions = a_; + } else { + pVertexAttributeDescriptions = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetVertexInputEXT) { vkb_srv_missing(c, "vkCmdSetVertexInputEXT"); return; } + c->dt->vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); +} + +void vkb_sv_vkCmdSetViewport(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstViewport; + vkb_dec_bytes(d, &firstViewport, sizeof(firstViewport)); + uint32_t viewportCount; + vkb_dec_bytes(d, &viewportCount, sizeof(viewportCount)); + const VkViewport *pViewports; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pViewports = (const VkViewport *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkViewport)); + } else { + pViewports = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetViewport) { vkb_srv_missing(c, "vkCmdSetViewport"); return; } + c->dt->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); +} + +void vkb_sv_vkCmdSetViewportSwizzleNV(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t firstViewport; + vkb_dec_bytes(d, &firstViewport, sizeof(firstViewport)); + uint32_t viewportCount; + vkb_dec_bytes(d, &viewportCount, sizeof(viewportCount)); + const VkViewportSwizzleNV *pViewportSwizzles; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pViewportSwizzles = (const VkViewportSwizzleNV *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkViewportSwizzleNV)); + } else { + pViewportSwizzles = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetViewportSwizzleNV) { vkb_srv_missing(c, "vkCmdSetViewportSwizzleNV"); return; } + c->dt->vkCmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles); +} + +void vkb_sv_vkCmdSetViewportWScalingEnableNV(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBool32 viewportWScalingEnable; + vkb_dec_bytes(d, &viewportWScalingEnable, sizeof(viewportWScalingEnable)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetViewportWScalingEnableNV) { vkb_srv_missing(c, "vkCmdSetViewportWScalingEnableNV"); return; } + c->dt->vkCmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable); +} + +void vkb_sv_vkCmdSetViewportWithCount(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t viewportCount; + vkb_dec_bytes(d, &viewportCount, sizeof(viewportCount)); + const VkViewport *pViewports; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pViewports = (const VkViewport *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkViewport)); + } else { + pViewports = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdSetViewportWithCount) { vkb_srv_missing(c, "vkCmdSetViewportWithCount"); return; } + c->dt->vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); +} + +void vkb_sv_vkCmdUpdateBuffer(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkBuffer dstBuffer; + vkb_dec_bytes(d, &dstBuffer, sizeof(dstBuffer)); + VkDeviceSize dstOffset; + vkb_dec_bytes(d, &dstOffset, sizeof(dstOffset)); + VkDeviceSize dataSize; + vkb_dec_bytes(d, &dataSize, sizeof(dataSize)); + const void *pData; + pData = (const void *)vkb_dec_blob(d, NULL); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdUpdateBuffer) { vkb_srv_missing(c, "vkCmdUpdateBuffer"); return; } + c->dt->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); +} + +void vkb_sv_vkCmdWaitEvents(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t eventCount; + vkb_dec_bytes(d, &eventCount, sizeof(eventCount)); + const VkEvent *pEvents; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pEvents = (const VkEvent *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkEvent)); + } else { + pEvents = NULL; + } + VkPipelineStageFlags srcStageMask; + vkb_dec_bytes(d, &srcStageMask, sizeof(srcStageMask)); + VkPipelineStageFlags dstStageMask; + vkb_dec_bytes(d, &dstStageMask, sizeof(dstStageMask)); + uint32_t memoryBarrierCount; + vkb_dec_bytes(d, &memoryBarrierCount, sizeof(memoryBarrierCount)); + const VkMemoryBarrier *pMemoryBarriers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkMemoryBarrier *a_ = (VkMemoryBarrier *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkMemoryBarrier)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkMemoryBarrier(d, &a_[i_]); + pMemoryBarriers = a_; + } else { + pMemoryBarriers = NULL; + } + uint32_t bufferMemoryBarrierCount; + vkb_dec_bytes(d, &bufferMemoryBarrierCount, sizeof(bufferMemoryBarrierCount)); + const VkBufferMemoryBarrier *pBufferMemoryBarriers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferMemoryBarrier *a_ = (VkBufferMemoryBarrier *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferMemoryBarrier)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferMemoryBarrier(d, &a_[i_]); + pBufferMemoryBarriers = a_; + } else { + pBufferMemoryBarriers = NULL; + } + uint32_t imageMemoryBarrierCount; + vkb_dec_bytes(d, &imageMemoryBarrierCount, sizeof(imageMemoryBarrierCount)); + const VkImageMemoryBarrier *pImageMemoryBarriers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageMemoryBarrier *a_ = (VkImageMemoryBarrier *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageMemoryBarrier)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageMemoryBarrier(d, &a_[i_]); + pImageMemoryBarriers = a_; + } else { + pImageMemoryBarriers = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdWaitEvents) { vkb_srv_missing(c, "vkCmdWaitEvents"); return; } + c->dt->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); +} + +void vkb_sv_vkCmdWaitEvents2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + uint32_t eventCount; + vkb_dec_bytes(d, &eventCount, sizeof(eventCount)); + const VkEvent *pEvents; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pEvents = (const VkEvent *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkEvent)); + } else { + pEvents = NULL; + } + const VkDependencyInfo *pDependencyInfos; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDependencyInfo *a_ = (VkDependencyInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDependencyInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDependencyInfo(d, &a_[i_]); + pDependencyInfos = a_; + } else { + pDependencyInfos = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdWaitEvents2) { vkb_srv_missing(c, "vkCmdWaitEvents2"); return; } + c->dt->vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); +} + +void vkb_sv_vkCmdWriteTimestamp(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkPipelineStageFlagBits pipelineStage; + vkb_dec_bytes(d, &pipelineStage, sizeof(pipelineStage)); + VkQueryPool queryPool; + vkb_dec_bytes(d, &queryPool, sizeof(queryPool)); + uint32_t query; + vkb_dec_bytes(d, &query, sizeof(query)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdWriteTimestamp) { vkb_srv_missing(c, "vkCmdWriteTimestamp"); return; } + c->dt->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); +} + +void vkb_sv_vkCmdWriteTimestamp2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkPipelineStageFlags2 stage; + vkb_dec_bytes(d, &stage, sizeof(stage)); + VkQueryPool queryPool; + vkb_dec_bytes(d, &queryPool, sizeof(queryPool)); + uint32_t query; + vkb_dec_bytes(d, &query, sizeof(query)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCmdWriteTimestamp2) { vkb_srv_missing(c, "vkCmdWriteTimestamp2"); return; } + c->dt->vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query); +} + +void vkb_sv_vkCreateBuffer(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkBufferCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferCreateInfo *a_ = (VkBufferCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pBuffer = vkb_dec_u8(d); + VkBuffer pBuffer_v; + memset(&pBuffer_v, 0, sizeof(pBuffer_v)); + if (has_pBuffer) vkb_dec_bytes(d, &pBuffer_v, sizeof(pBuffer_v)); + VkBuffer *pBuffer = has_pBuffer ? &pBuffer_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateBuffer) { vkb_srv_missing(c, "vkCreateBuffer"); return; } + VkResult r_ = c->dt->vkCreateBuffer(device, pCreateInfo, NULL, pBuffer); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pBuffer != NULL); + if (pBuffer) vkb_enc_raw(e, pBuffer, sizeof(*pBuffer)); +} + +void vkb_sv_vkCreateBufferView(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkBufferViewCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferViewCreateInfo *a_ = (VkBufferViewCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferViewCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferViewCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pView = vkb_dec_u8(d); + VkBufferView pView_v; + memset(&pView_v, 0, sizeof(pView_v)); + if (has_pView) vkb_dec_bytes(d, &pView_v, sizeof(pView_v)); + VkBufferView *pView = has_pView ? &pView_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateBufferView) { vkb_srv_missing(c, "vkCreateBufferView"); return; } + VkResult r_ = c->dt->vkCreateBufferView(device, pCreateInfo, NULL, pView); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pView != NULL); + if (pView) vkb_enc_raw(e, pView, sizeof(*pView)); +} + +void vkb_sv_vkCreateCommandPool(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkCommandPoolCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCommandPoolCreateInfo *a_ = (VkCommandPoolCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCommandPoolCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkCommandPoolCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pCommandPool = vkb_dec_u8(d); + VkCommandPool pCommandPool_v; + memset(&pCommandPool_v, 0, sizeof(pCommandPool_v)); + if (has_pCommandPool) vkb_dec_bytes(d, &pCommandPool_v, sizeof(pCommandPool_v)); + VkCommandPool *pCommandPool = has_pCommandPool ? &pCommandPool_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateCommandPool) { vkb_srv_missing(c, "vkCreateCommandPool"); return; } + VkResult r_ = c->dt->vkCreateCommandPool(device, pCreateInfo, NULL, pCommandPool); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pCommandPool != NULL); + if (pCommandPool) vkb_enc_raw(e, pCommandPool, sizeof(*pCommandPool)); +} + +void vkb_sv_vkCreateComputePipelines(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkPipelineCache pipelineCache; + vkb_dec_bytes(d, &pipelineCache, sizeof(pipelineCache)); + uint32_t createInfoCount; + vkb_dec_bytes(d, &createInfoCount, sizeof(createInfoCount)); + const VkComputePipelineCreateInfo *pCreateInfos; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkComputePipelineCreateInfo *a_ = (VkComputePipelineCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkComputePipelineCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkComputePipelineCreateInfo(d, &a_[i_]); + pCreateInfos = a_; + } else { + pCreateInfos = NULL; + } + uint8_t has_pPipelines = vkb_dec_u8(d); uint32_t n_pPipelines = vkb_dec_u32(d); + VkPipeline *pPipelines = has_pPipelines ? (VkPipeline *)vkb_dec_alloc_zero(d, (size_t)n_pPipelines * sizeof(VkPipeline)) : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateComputePipelines) { vkb_srv_missing(c, "vkCreateComputePipelines"); return; } + VkResult r_ = c->dt->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines); + vkb_enc_bytes(e, &r_, sizeof(r_)); + { + uint32_t rn_ = n_pPipelines; + uint32_t has_ = pPipelines ? (rn_ < n_pPipelines ? rn_ : n_pPipelines) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &pPipelines[i_], sizeof(VkPipeline)); + } +} + +void vkb_sv_vkCreateDescriptorPool(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkDescriptorPoolCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDescriptorPoolCreateInfo *a_ = (VkDescriptorPoolCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDescriptorPoolCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDescriptorPoolCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pDescriptorPool = vkb_dec_u8(d); + VkDescriptorPool pDescriptorPool_v; + memset(&pDescriptorPool_v, 0, sizeof(pDescriptorPool_v)); + if (has_pDescriptorPool) vkb_dec_bytes(d, &pDescriptorPool_v, sizeof(pDescriptorPool_v)); + VkDescriptorPool *pDescriptorPool = has_pDescriptorPool ? &pDescriptorPool_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateDescriptorPool) { vkb_srv_missing(c, "vkCreateDescriptorPool"); return; } + VkResult r_ = c->dt->vkCreateDescriptorPool(device, pCreateInfo, NULL, pDescriptorPool); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pDescriptorPool != NULL); + if (pDescriptorPool) vkb_enc_raw(e, pDescriptorPool, sizeof(*pDescriptorPool)); +} + +void vkb_sv_vkCreateDescriptorSetLayout(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkDescriptorSetLayoutCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDescriptorSetLayoutCreateInfo *a_ = (VkDescriptorSetLayoutCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDescriptorSetLayoutCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDescriptorSetLayoutCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pSetLayout = vkb_dec_u8(d); + VkDescriptorSetLayout pSetLayout_v; + memset(&pSetLayout_v, 0, sizeof(pSetLayout_v)); + if (has_pSetLayout) vkb_dec_bytes(d, &pSetLayout_v, sizeof(pSetLayout_v)); + VkDescriptorSetLayout *pSetLayout = has_pSetLayout ? &pSetLayout_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateDescriptorSetLayout) { vkb_srv_missing(c, "vkCreateDescriptorSetLayout"); return; } + VkResult r_ = c->dt->vkCreateDescriptorSetLayout(device, pCreateInfo, NULL, pSetLayout); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pSetLayout != NULL); + if (pSetLayout) vkb_enc_raw(e, pSetLayout, sizeof(*pSetLayout)); +} + +void vkb_sv_vkCreateDescriptorUpdateTemplate(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDescriptorUpdateTemplateCreateInfo *a_ = (VkDescriptorUpdateTemplateCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDescriptorUpdateTemplateCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDescriptorUpdateTemplateCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pDescriptorUpdateTemplate = vkb_dec_u8(d); + VkDescriptorUpdateTemplate pDescriptorUpdateTemplate_v; + memset(&pDescriptorUpdateTemplate_v, 0, sizeof(pDescriptorUpdateTemplate_v)); + if (has_pDescriptorUpdateTemplate) vkb_dec_bytes(d, &pDescriptorUpdateTemplate_v, sizeof(pDescriptorUpdateTemplate_v)); + VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate = has_pDescriptorUpdateTemplate ? &pDescriptorUpdateTemplate_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateDescriptorUpdateTemplate) { vkb_srv_missing(c, "vkCreateDescriptorUpdateTemplate"); return; } + VkResult r_ = c->dt->vkCreateDescriptorUpdateTemplate(device, pCreateInfo, NULL, pDescriptorUpdateTemplate); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pDescriptorUpdateTemplate != NULL); + if (pDescriptorUpdateTemplate) vkb_enc_raw(e, pDescriptorUpdateTemplate, sizeof(*pDescriptorUpdateTemplate)); +} + +void vkb_sv_vkCreateEvent(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkEventCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkEventCreateInfo *a_ = (VkEventCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkEventCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkEventCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pEvent = vkb_dec_u8(d); + VkEvent pEvent_v; + memset(&pEvent_v, 0, sizeof(pEvent_v)); + if (has_pEvent) vkb_dec_bytes(d, &pEvent_v, sizeof(pEvent_v)); + VkEvent *pEvent = has_pEvent ? &pEvent_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateEvent) { vkb_srv_missing(c, "vkCreateEvent"); return; } + VkResult r_ = c->dt->vkCreateEvent(device, pCreateInfo, NULL, pEvent); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pEvent != NULL); + if (pEvent) vkb_enc_raw(e, pEvent, sizeof(*pEvent)); +} + +void vkb_sv_vkCreateFence(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkFenceCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkFenceCreateInfo *a_ = (VkFenceCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkFenceCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkFenceCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pFence = vkb_dec_u8(d); + VkFence pFence_v; + memset(&pFence_v, 0, sizeof(pFence_v)); + if (has_pFence) vkb_dec_bytes(d, &pFence_v, sizeof(pFence_v)); + VkFence *pFence = has_pFence ? &pFence_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateFence) { vkb_srv_missing(c, "vkCreateFence"); return; } + VkResult r_ = c->dt->vkCreateFence(device, pCreateInfo, NULL, pFence); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pFence != NULL); + if (pFence) vkb_enc_raw(e, pFence, sizeof(*pFence)); +} + +void vkb_sv_vkCreateFramebuffer(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkFramebufferCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkFramebufferCreateInfo *a_ = (VkFramebufferCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkFramebufferCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkFramebufferCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pFramebuffer = vkb_dec_u8(d); + VkFramebuffer pFramebuffer_v; + memset(&pFramebuffer_v, 0, sizeof(pFramebuffer_v)); + if (has_pFramebuffer) vkb_dec_bytes(d, &pFramebuffer_v, sizeof(pFramebuffer_v)); + VkFramebuffer *pFramebuffer = has_pFramebuffer ? &pFramebuffer_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateFramebuffer) { vkb_srv_missing(c, "vkCreateFramebuffer"); return; } + VkResult r_ = c->dt->vkCreateFramebuffer(device, pCreateInfo, NULL, pFramebuffer); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pFramebuffer != NULL); + if (pFramebuffer) vkb_enc_raw(e, pFramebuffer, sizeof(*pFramebuffer)); +} + +void vkb_sv_vkCreateGraphicsPipelines(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkPipelineCache pipelineCache; + vkb_dec_bytes(d, &pipelineCache, sizeof(pipelineCache)); + uint32_t createInfoCount; + vkb_dec_bytes(d, &createInfoCount, sizeof(createInfoCount)); + const VkGraphicsPipelineCreateInfo *pCreateInfos; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkGraphicsPipelineCreateInfo *a_ = (VkGraphicsPipelineCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkGraphicsPipelineCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkGraphicsPipelineCreateInfo(d, &a_[i_]); + pCreateInfos = a_; + } else { + pCreateInfos = NULL; + } + uint8_t has_pPipelines = vkb_dec_u8(d); uint32_t n_pPipelines = vkb_dec_u32(d); + VkPipeline *pPipelines = has_pPipelines ? (VkPipeline *)vkb_dec_alloc_zero(d, (size_t)n_pPipelines * sizeof(VkPipeline)) : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateGraphicsPipelines) { vkb_srv_missing(c, "vkCreateGraphicsPipelines"); return; } + VkResult r_ = c->dt->vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines); + vkb_enc_bytes(e, &r_, sizeof(r_)); + { + uint32_t rn_ = n_pPipelines; + uint32_t has_ = pPipelines ? (rn_ < n_pPipelines ? rn_ : n_pPipelines) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &pPipelines[i_], sizeof(VkPipeline)); + } +} + +void vkb_sv_vkCreateImage(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkImageCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageCreateInfo *a_ = (VkImageCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pImage = vkb_dec_u8(d); + VkImage pImage_v; + memset(&pImage_v, 0, sizeof(pImage_v)); + if (has_pImage) vkb_dec_bytes(d, &pImage_v, sizeof(pImage_v)); + VkImage *pImage = has_pImage ? &pImage_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateImage) { vkb_srv_missing(c, "vkCreateImage"); return; } + VkResult r_ = c->dt->vkCreateImage(device, pCreateInfo, NULL, pImage); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pImage != NULL); + if (pImage) vkb_enc_raw(e, pImage, sizeof(*pImage)); +} + +void vkb_sv_vkCreateImageView(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkImageViewCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageViewCreateInfo *a_ = (VkImageViewCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageViewCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageViewCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pView = vkb_dec_u8(d); + VkImageView pView_v; + memset(&pView_v, 0, sizeof(pView_v)); + if (has_pView) vkb_dec_bytes(d, &pView_v, sizeof(pView_v)); + VkImageView *pView = has_pView ? &pView_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateImageView) { vkb_srv_missing(c, "vkCreateImageView"); return; } + VkResult r_ = c->dt->vkCreateImageView(device, pCreateInfo, NULL, pView); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pView != NULL); + if (pView) vkb_enc_raw(e, pView, sizeof(*pView)); +} + +void vkb_sv_vkCreatePipelineCache(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkPipelineCacheCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineCacheCreateInfo *a_ = (VkPipelineCacheCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineCacheCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineCacheCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pPipelineCache = vkb_dec_u8(d); + VkPipelineCache pPipelineCache_v; + memset(&pPipelineCache_v, 0, sizeof(pPipelineCache_v)); + if (has_pPipelineCache) vkb_dec_bytes(d, &pPipelineCache_v, sizeof(pPipelineCache_v)); + VkPipelineCache *pPipelineCache = has_pPipelineCache ? &pPipelineCache_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreatePipelineCache) { vkb_srv_missing(c, "vkCreatePipelineCache"); return; } + VkResult r_ = c->dt->vkCreatePipelineCache(device, pCreateInfo, NULL, pPipelineCache); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pPipelineCache != NULL); + if (pPipelineCache) vkb_enc_raw(e, pPipelineCache, sizeof(*pPipelineCache)); +} + +void vkb_sv_vkCreatePipelineLayout(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkPipelineLayoutCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineLayoutCreateInfo *a_ = (VkPipelineLayoutCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineLayoutCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineLayoutCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pPipelineLayout = vkb_dec_u8(d); + VkPipelineLayout pPipelineLayout_v; + memset(&pPipelineLayout_v, 0, sizeof(pPipelineLayout_v)); + if (has_pPipelineLayout) vkb_dec_bytes(d, &pPipelineLayout_v, sizeof(pPipelineLayout_v)); + VkPipelineLayout *pPipelineLayout = has_pPipelineLayout ? &pPipelineLayout_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreatePipelineLayout) { vkb_srv_missing(c, "vkCreatePipelineLayout"); return; } + VkResult r_ = c->dt->vkCreatePipelineLayout(device, pCreateInfo, NULL, pPipelineLayout); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pPipelineLayout != NULL); + if (pPipelineLayout) vkb_enc_raw(e, pPipelineLayout, sizeof(*pPipelineLayout)); +} + +void vkb_sv_vkCreateQueryPool(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkQueryPoolCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkQueryPoolCreateInfo *a_ = (VkQueryPoolCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkQueryPoolCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkQueryPoolCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pQueryPool = vkb_dec_u8(d); + VkQueryPool pQueryPool_v; + memset(&pQueryPool_v, 0, sizeof(pQueryPool_v)); + if (has_pQueryPool) vkb_dec_bytes(d, &pQueryPool_v, sizeof(pQueryPool_v)); + VkQueryPool *pQueryPool = has_pQueryPool ? &pQueryPool_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateQueryPool) { vkb_srv_missing(c, "vkCreateQueryPool"); return; } + VkResult r_ = c->dt->vkCreateQueryPool(device, pCreateInfo, NULL, pQueryPool); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pQueryPool != NULL); + if (pQueryPool) vkb_enc_raw(e, pQueryPool, sizeof(*pQueryPool)); +} + +void vkb_sv_vkCreateRenderPass(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkRenderPassCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkRenderPassCreateInfo *a_ = (VkRenderPassCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkRenderPassCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkRenderPassCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pRenderPass = vkb_dec_u8(d); + VkRenderPass pRenderPass_v; + memset(&pRenderPass_v, 0, sizeof(pRenderPass_v)); + if (has_pRenderPass) vkb_dec_bytes(d, &pRenderPass_v, sizeof(pRenderPass_v)); + VkRenderPass *pRenderPass = has_pRenderPass ? &pRenderPass_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateRenderPass) { vkb_srv_missing(c, "vkCreateRenderPass"); return; } + VkResult r_ = c->dt->vkCreateRenderPass(device, pCreateInfo, NULL, pRenderPass); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pRenderPass != NULL); + if (pRenderPass) vkb_enc_raw(e, pRenderPass, sizeof(*pRenderPass)); +} + +void vkb_sv_vkCreateRenderPass2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkRenderPassCreateInfo2 *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkRenderPassCreateInfo2 *a_ = (VkRenderPassCreateInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkRenderPassCreateInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkRenderPassCreateInfo2(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pRenderPass = vkb_dec_u8(d); + VkRenderPass pRenderPass_v; + memset(&pRenderPass_v, 0, sizeof(pRenderPass_v)); + if (has_pRenderPass) vkb_dec_bytes(d, &pRenderPass_v, sizeof(pRenderPass_v)); + VkRenderPass *pRenderPass = has_pRenderPass ? &pRenderPass_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateRenderPass2) { vkb_srv_missing(c, "vkCreateRenderPass2"); return; } + VkResult r_ = c->dt->vkCreateRenderPass2(device, pCreateInfo, NULL, pRenderPass); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pRenderPass != NULL); + if (pRenderPass) vkb_enc_raw(e, pRenderPass, sizeof(*pRenderPass)); +} + +void vkb_sv_vkCreateSampler(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkSamplerCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSamplerCreateInfo *a_ = (VkSamplerCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSamplerCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSamplerCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pSampler = vkb_dec_u8(d); + VkSampler pSampler_v; + memset(&pSampler_v, 0, sizeof(pSampler_v)); + if (has_pSampler) vkb_dec_bytes(d, &pSampler_v, sizeof(pSampler_v)); + VkSampler *pSampler = has_pSampler ? &pSampler_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateSampler) { vkb_srv_missing(c, "vkCreateSampler"); return; } + VkResult r_ = c->dt->vkCreateSampler(device, pCreateInfo, NULL, pSampler); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pSampler != NULL); + if (pSampler) vkb_enc_raw(e, pSampler, sizeof(*pSampler)); +} + +void vkb_sv_vkCreateSamplerYcbcrConversion(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkSamplerYcbcrConversionCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSamplerYcbcrConversionCreateInfo *a_ = (VkSamplerYcbcrConversionCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSamplerYcbcrConversionCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSamplerYcbcrConversionCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pYcbcrConversion = vkb_dec_u8(d); + VkSamplerYcbcrConversion pYcbcrConversion_v; + memset(&pYcbcrConversion_v, 0, sizeof(pYcbcrConversion_v)); + if (has_pYcbcrConversion) vkb_dec_bytes(d, &pYcbcrConversion_v, sizeof(pYcbcrConversion_v)); + VkSamplerYcbcrConversion *pYcbcrConversion = has_pYcbcrConversion ? &pYcbcrConversion_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateSamplerYcbcrConversion) { vkb_srv_missing(c, "vkCreateSamplerYcbcrConversion"); return; } + VkResult r_ = c->dt->vkCreateSamplerYcbcrConversion(device, pCreateInfo, NULL, pYcbcrConversion); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pYcbcrConversion != NULL); + if (pYcbcrConversion) vkb_enc_raw(e, pYcbcrConversion, sizeof(*pYcbcrConversion)); +} + +void vkb_sv_vkCreateSemaphore(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkSemaphoreCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSemaphoreCreateInfo *a_ = (VkSemaphoreCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSemaphoreCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSemaphoreCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pSemaphore = vkb_dec_u8(d); + VkSemaphore pSemaphore_v; + memset(&pSemaphore_v, 0, sizeof(pSemaphore_v)); + if (has_pSemaphore) vkb_dec_bytes(d, &pSemaphore_v, sizeof(pSemaphore_v)); + VkSemaphore *pSemaphore = has_pSemaphore ? &pSemaphore_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateSemaphore) { vkb_srv_missing(c, "vkCreateSemaphore"); return; } + VkResult r_ = c->dt->vkCreateSemaphore(device, pCreateInfo, NULL, pSemaphore); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pSemaphore != NULL); + if (pSemaphore) vkb_enc_raw(e, pSemaphore, sizeof(*pSemaphore)); +} + +void vkb_sv_vkCreateShaderModule(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkShaderModuleCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkShaderModuleCreateInfo *a_ = (VkShaderModuleCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkShaderModuleCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkShaderModuleCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pShaderModule = vkb_dec_u8(d); + VkShaderModule pShaderModule_v; + memset(&pShaderModule_v, 0, sizeof(pShaderModule_v)); + if (has_pShaderModule) vkb_dec_bytes(d, &pShaderModule_v, sizeof(pShaderModule_v)); + VkShaderModule *pShaderModule = has_pShaderModule ? &pShaderModule_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkCreateShaderModule) { vkb_srv_missing(c, "vkCreateShaderModule"); return; } + VkResult r_ = c->dt->vkCreateShaderModule(device, pCreateInfo, NULL, pShaderModule); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pShaderModule != NULL); + if (pShaderModule) vkb_enc_raw(e, pShaderModule, sizeof(*pShaderModule)); +} + +void vkb_sv_vkDestroyBuffer(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkBuffer buffer; + vkb_dec_bytes(d, &buffer, sizeof(buffer)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyBuffer) { vkb_srv_missing(c, "vkDestroyBuffer"); return; } + c->dt->vkDestroyBuffer(device, buffer, NULL); +} + +void vkb_sv_vkDestroyBufferView(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkBufferView bufferView; + vkb_dec_bytes(d, &bufferView, sizeof(bufferView)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyBufferView) { vkb_srv_missing(c, "vkDestroyBufferView"); return; } + c->dt->vkDestroyBufferView(device, bufferView, NULL); +} + +void vkb_sv_vkDestroyCommandPool(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkCommandPool commandPool; + vkb_dec_bytes(d, &commandPool, sizeof(commandPool)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyCommandPool) { vkb_srv_missing(c, "vkDestroyCommandPool"); return; } + c->dt->vkDestroyCommandPool(device, commandPool, NULL); +} + +void vkb_sv_vkDestroyDescriptorPool(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkDescriptorPool descriptorPool; + vkb_dec_bytes(d, &descriptorPool, sizeof(descriptorPool)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyDescriptorPool) { vkb_srv_missing(c, "vkDestroyDescriptorPool"); return; } + c->dt->vkDestroyDescriptorPool(device, descriptorPool, NULL); +} + +void vkb_sv_vkDestroyDescriptorSetLayout(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkDescriptorSetLayout descriptorSetLayout; + vkb_dec_bytes(d, &descriptorSetLayout, sizeof(descriptorSetLayout)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyDescriptorSetLayout) { vkb_srv_missing(c, "vkDestroyDescriptorSetLayout"); return; } + c->dt->vkDestroyDescriptorSetLayout(device, descriptorSetLayout, NULL); +} + +void vkb_sv_vkDestroyDescriptorUpdateTemplate(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkDescriptorUpdateTemplate descriptorUpdateTemplate; + vkb_dec_bytes(d, &descriptorUpdateTemplate, sizeof(descriptorUpdateTemplate)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyDescriptorUpdateTemplate) { vkb_srv_missing(c, "vkDestroyDescriptorUpdateTemplate"); return; } + c->dt->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, NULL); +} + +void vkb_sv_vkDestroyEvent(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkEvent event; + vkb_dec_bytes(d, &event, sizeof(event)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyEvent) { vkb_srv_missing(c, "vkDestroyEvent"); return; } + c->dt->vkDestroyEvent(device, event, NULL); +} + +void vkb_sv_vkDestroyFence(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkFence fence; + vkb_dec_bytes(d, &fence, sizeof(fence)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyFence) { vkb_srv_missing(c, "vkDestroyFence"); return; } + c->dt->vkDestroyFence(device, fence, NULL); +} + +void vkb_sv_vkDestroyFramebuffer(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkFramebuffer framebuffer; + vkb_dec_bytes(d, &framebuffer, sizeof(framebuffer)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyFramebuffer) { vkb_srv_missing(c, "vkDestroyFramebuffer"); return; } + c->dt->vkDestroyFramebuffer(device, framebuffer, NULL); +} + +void vkb_sv_vkDestroyImage(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkImage image; + vkb_dec_bytes(d, &image, sizeof(image)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyImage) { vkb_srv_missing(c, "vkDestroyImage"); return; } + c->dt->vkDestroyImage(device, image, NULL); +} + +void vkb_sv_vkDestroyImageView(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkImageView imageView; + vkb_dec_bytes(d, &imageView, sizeof(imageView)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyImageView) { vkb_srv_missing(c, "vkDestroyImageView"); return; } + c->dt->vkDestroyImageView(device, imageView, NULL); +} + +void vkb_sv_vkDestroyPipeline(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkPipeline pipeline; + vkb_dec_bytes(d, &pipeline, sizeof(pipeline)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyPipeline) { vkb_srv_missing(c, "vkDestroyPipeline"); return; } + c->dt->vkDestroyPipeline(device, pipeline, NULL); +} + +void vkb_sv_vkDestroyPipelineCache(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkPipelineCache pipelineCache; + vkb_dec_bytes(d, &pipelineCache, sizeof(pipelineCache)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyPipelineCache) { vkb_srv_missing(c, "vkDestroyPipelineCache"); return; } + c->dt->vkDestroyPipelineCache(device, pipelineCache, NULL); +} + +void vkb_sv_vkDestroyPipelineLayout(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkPipelineLayout pipelineLayout; + vkb_dec_bytes(d, &pipelineLayout, sizeof(pipelineLayout)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyPipelineLayout) { vkb_srv_missing(c, "vkDestroyPipelineLayout"); return; } + c->dt->vkDestroyPipelineLayout(device, pipelineLayout, NULL); +} + +void vkb_sv_vkDestroyQueryPool(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkQueryPool queryPool; + vkb_dec_bytes(d, &queryPool, sizeof(queryPool)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyQueryPool) { vkb_srv_missing(c, "vkDestroyQueryPool"); return; } + c->dt->vkDestroyQueryPool(device, queryPool, NULL); +} + +void vkb_sv_vkDestroyRenderPass(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkRenderPass renderPass; + vkb_dec_bytes(d, &renderPass, sizeof(renderPass)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyRenderPass) { vkb_srv_missing(c, "vkDestroyRenderPass"); return; } + c->dt->vkDestroyRenderPass(device, renderPass, NULL); +} + +void vkb_sv_vkDestroySampler(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkSampler sampler; + vkb_dec_bytes(d, &sampler, sizeof(sampler)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroySampler) { vkb_srv_missing(c, "vkDestroySampler"); return; } + c->dt->vkDestroySampler(device, sampler, NULL); +} + +void vkb_sv_vkDestroySamplerYcbcrConversion(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkSamplerYcbcrConversion ycbcrConversion; + vkb_dec_bytes(d, &ycbcrConversion, sizeof(ycbcrConversion)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroySamplerYcbcrConversion) { vkb_srv_missing(c, "vkDestroySamplerYcbcrConversion"); return; } + c->dt->vkDestroySamplerYcbcrConversion(device, ycbcrConversion, NULL); +} + +void vkb_sv_vkDestroySemaphore(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkSemaphore semaphore; + vkb_dec_bytes(d, &semaphore, sizeof(semaphore)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroySemaphore) { vkb_srv_missing(c, "vkDestroySemaphore"); return; } + c->dt->vkDestroySemaphore(device, semaphore, NULL); +} + +void vkb_sv_vkDestroyShaderModule(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkShaderModule shaderModule; + vkb_dec_bytes(d, &shaderModule, sizeof(shaderModule)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDestroyShaderModule) { vkb_srv_missing(c, "vkDestroyShaderModule"); return; } + c->dt->vkDestroyShaderModule(device, shaderModule, NULL); +} + +void vkb_sv_vkDeviceWaitIdle(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkDeviceWaitIdle) { vkb_srv_missing(c, "vkDeviceWaitIdle"); return; } + VkResult r_ = c->dt->vkDeviceWaitIdle(device); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkEnumerateDeviceExtensionProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + const char *pLayerName; + pLayerName = vkb_dec_str(d); + uint8_t has_pPropertyCount = vkb_dec_u8(d); + uint32_t pPropertyCount_v; + memset(&pPropertyCount_v, 0, sizeof(pPropertyCount_v)); + if (has_pPropertyCount) vkb_dec_bytes(d, &pPropertyCount_v, sizeof(pPropertyCount_v)); + uint32_t *pPropertyCount = has_pPropertyCount ? &pPropertyCount_v : NULL; + uint8_t has_pProperties = vkb_dec_u8(d); uint32_t n_pProperties = vkb_dec_u32(d); + VkExtensionProperties *pProperties = has_pProperties ? (VkExtensionProperties *)vkb_dec_alloc_zero(d, (size_t)n_pProperties * sizeof(VkExtensionProperties)) : NULL; + if (pProperties && pPropertyCount) *pPropertyCount = n_pProperties; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkEnumerateDeviceExtensionProperties) { vkb_srv_missing(c, "vkEnumerateDeviceExtensionProperties"); return; } + VkResult r_ = c->dt->vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pPropertyCount != NULL); + if (pPropertyCount) vkb_enc_raw(e, pPropertyCount, sizeof(*pPropertyCount)); + { + uint32_t rn_ = (pPropertyCount ? *pPropertyCount : 0); + uint32_t has_ = pProperties ? (rn_ < n_pProperties ? rn_ : n_pProperties) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &pProperties[i_], sizeof(VkExtensionProperties)); + } +} + +void vkb_sv_vkEnumerateInstanceExtensionProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + const char *pLayerName; + pLayerName = vkb_dec_str(d); + uint8_t has_pPropertyCount = vkb_dec_u8(d); + uint32_t pPropertyCount_v; + memset(&pPropertyCount_v, 0, sizeof(pPropertyCount_v)); + if (has_pPropertyCount) vkb_dec_bytes(d, &pPropertyCount_v, sizeof(pPropertyCount_v)); + uint32_t *pPropertyCount = has_pPropertyCount ? &pPropertyCount_v : NULL; + uint8_t has_pProperties = vkb_dec_u8(d); uint32_t n_pProperties = vkb_dec_u32(d); + VkExtensionProperties *pProperties = has_pProperties ? (VkExtensionProperties *)vkb_dec_alloc_zero(d, (size_t)n_pProperties * sizeof(VkExtensionProperties)) : NULL; + if (pProperties && pPropertyCount) *pPropertyCount = n_pProperties; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkEnumerateInstanceExtensionProperties) { vkb_srv_missing(c, "vkEnumerateInstanceExtensionProperties"); return; } + VkResult r_ = c->dt->vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pPropertyCount != NULL); + if (pPropertyCount) vkb_enc_raw(e, pPropertyCount, sizeof(*pPropertyCount)); + { + uint32_t rn_ = (pPropertyCount ? *pPropertyCount : 0); + uint32_t has_ = pProperties ? (rn_ < n_pProperties ? rn_ : n_pProperties) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &pProperties[i_], sizeof(VkExtensionProperties)); + } +} + +void vkb_sv_vkEnumerateInstanceLayerProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + uint8_t has_pPropertyCount = vkb_dec_u8(d); + uint32_t pPropertyCount_v; + memset(&pPropertyCount_v, 0, sizeof(pPropertyCount_v)); + if (has_pPropertyCount) vkb_dec_bytes(d, &pPropertyCount_v, sizeof(pPropertyCount_v)); + uint32_t *pPropertyCount = has_pPropertyCount ? &pPropertyCount_v : NULL; + uint8_t has_pProperties = vkb_dec_u8(d); uint32_t n_pProperties = vkb_dec_u32(d); + VkLayerProperties *pProperties = has_pProperties ? (VkLayerProperties *)vkb_dec_alloc_zero(d, (size_t)n_pProperties * sizeof(VkLayerProperties)) : NULL; + if (pProperties && pPropertyCount) *pPropertyCount = n_pProperties; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkEnumerateInstanceLayerProperties) { vkb_srv_missing(c, "vkEnumerateInstanceLayerProperties"); return; } + VkResult r_ = c->dt->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pPropertyCount != NULL); + if (pPropertyCount) vkb_enc_raw(e, pPropertyCount, sizeof(*pPropertyCount)); + { + uint32_t rn_ = (pPropertyCount ? *pPropertyCount : 0); + uint32_t has_ = pProperties ? (rn_ < n_pProperties ? rn_ : n_pProperties) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &pProperties[i_], sizeof(VkLayerProperties)); + } +} + +void vkb_sv_vkEnumerateInstanceVersion(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + uint8_t has_pApiVersion = vkb_dec_u8(d); + uint32_t pApiVersion_v; + memset(&pApiVersion_v, 0, sizeof(pApiVersion_v)); + if (has_pApiVersion) vkb_dec_bytes(d, &pApiVersion_v, sizeof(pApiVersion_v)); + uint32_t *pApiVersion = has_pApiVersion ? &pApiVersion_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkEnumerateInstanceVersion) { vkb_srv_missing(c, "vkEnumerateInstanceVersion"); return; } + VkResult r_ = c->dt->vkEnumerateInstanceVersion(pApiVersion); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pApiVersion != NULL); + if (pApiVersion) vkb_enc_raw(e, pApiVersion, sizeof(*pApiVersion)); +} + +void vkb_sv_vkEnumeratePhysicalDeviceGroups(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkInstance instance = (VkInstance)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pPhysicalDeviceGroupCount = vkb_dec_u8(d); + uint32_t pPhysicalDeviceGroupCount_v; + memset(&pPhysicalDeviceGroupCount_v, 0, sizeof(pPhysicalDeviceGroupCount_v)); + if (has_pPhysicalDeviceGroupCount) vkb_dec_bytes(d, &pPhysicalDeviceGroupCount_v, sizeof(pPhysicalDeviceGroupCount_v)); + uint32_t *pPhysicalDeviceGroupCount = has_pPhysicalDeviceGroupCount ? &pPhysicalDeviceGroupCount_v : NULL; + uint8_t has_pPhysicalDeviceGroupProperties = vkb_dec_u8(d); uint32_t n_pPhysicalDeviceGroupProperties = vkb_dec_u32(d); + VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties = has_pPhysicalDeviceGroupProperties ? (VkPhysicalDeviceGroupProperties *)vkb_dec_alloc_zero(d, (size_t)n_pPhysicalDeviceGroupProperties * sizeof(VkPhysicalDeviceGroupProperties)) : NULL; + for (uint32_t i_ = 0; pPhysicalDeviceGroupProperties && i_ < n_pPhysicalDeviceGroupProperties; i_++) vkb_dec_out_template(d, &pPhysicalDeviceGroupProperties[i_], sizeof(VkPhysicalDeviceGroupProperties)); + if (pPhysicalDeviceGroupProperties && pPhysicalDeviceGroupCount) *pPhysicalDeviceGroupCount = n_pPhysicalDeviceGroupProperties; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkEnumeratePhysicalDeviceGroups) { vkb_srv_missing(c, "vkEnumeratePhysicalDeviceGroups"); return; } + VkResult r_ = c->dt->vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pPhysicalDeviceGroupCount != NULL); + if (pPhysicalDeviceGroupCount) vkb_enc_raw(e, pPhysicalDeviceGroupCount, sizeof(*pPhysicalDeviceGroupCount)); + { + uint32_t rn_ = (pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0); + uint32_t has_ = pPhysicalDeviceGroupProperties ? (rn_ < n_pPhysicalDeviceGroupProperties ? rn_ : n_pPhysicalDeviceGroupProperties) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_out_struct(e, &pPhysicalDeviceGroupProperties[i_], sizeof(VkPhysicalDeviceGroupProperties)); + } +} + +void vkb_sv_vkEnumeratePhysicalDevices(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkInstance instance = (VkInstance)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pPhysicalDeviceCount = vkb_dec_u8(d); + uint32_t pPhysicalDeviceCount_v; + memset(&pPhysicalDeviceCount_v, 0, sizeof(pPhysicalDeviceCount_v)); + if (has_pPhysicalDeviceCount) vkb_dec_bytes(d, &pPhysicalDeviceCount_v, sizeof(pPhysicalDeviceCount_v)); + uint32_t *pPhysicalDeviceCount = has_pPhysicalDeviceCount ? &pPhysicalDeviceCount_v : NULL; + uint8_t has_pPhysicalDevices = vkb_dec_u8(d); uint32_t n_pPhysicalDevices = vkb_dec_u32(d); + VkPhysicalDevice *pPhysicalDevices = has_pPhysicalDevices ? (VkPhysicalDevice *)vkb_dec_alloc_zero(d, (size_t)n_pPhysicalDevices * sizeof(VkPhysicalDevice)) : NULL; + if (pPhysicalDevices && pPhysicalDeviceCount) *pPhysicalDeviceCount = n_pPhysicalDevices; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkEnumeratePhysicalDevices) { vkb_srv_missing(c, "vkEnumeratePhysicalDevices"); return; } + VkResult r_ = c->dt->vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pPhysicalDeviceCount != NULL); + if (pPhysicalDeviceCount) vkb_enc_raw(e, pPhysicalDeviceCount, sizeof(*pPhysicalDeviceCount)); + { + uint32_t rn_ = (pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0); + uint32_t has_ = pPhysicalDevices ? (rn_ < n_pPhysicalDevices ? rn_ : n_pPhysicalDevices) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_u64(e, (uint64_t)(uintptr_t)pPhysicalDevices[i_]); + } +} + +void vkb_sv_vkFreeCommandBuffers(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkCommandPool commandPool; + vkb_dec_bytes(d, &commandPool, sizeof(commandPool)); + uint32_t commandBufferCount; + vkb_dec_bytes(d, &commandBufferCount, sizeof(commandBufferCount)); + const VkCommandBuffer *pCommandBuffers; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCommandBuffer *a_ = (VkCommandBuffer *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCommandBuffer)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) a_[i_] = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + pCommandBuffers = a_; + } else { + pCommandBuffers = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkFreeCommandBuffers) { vkb_srv_missing(c, "vkFreeCommandBuffers"); return; } + c->dt->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); +} + +void vkb_sv_vkFreeDescriptorSets(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkDescriptorPool descriptorPool; + vkb_dec_bytes(d, &descriptorPool, sizeof(descriptorPool)); + uint32_t descriptorSetCount; + vkb_dec_bytes(d, &descriptorSetCount, sizeof(descriptorSetCount)); + const VkDescriptorSet *pDescriptorSets; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pDescriptorSets = (const VkDescriptorSet *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDescriptorSet)); + } else { + pDescriptorSets = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkFreeDescriptorSets) { vkb_srv_missing(c, "vkFreeDescriptorSets"); return; } + VkResult r_ = c->dt->vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkGetBufferDeviceAddress(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkBufferDeviceAddressInfo *pInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferDeviceAddressInfo *a_ = (VkBufferDeviceAddressInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferDeviceAddressInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferDeviceAddressInfo(d, &a_[i_]); + pInfo = a_; + } else { + pInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetBufferDeviceAddress) { vkb_srv_missing(c, "vkGetBufferDeviceAddress"); return; } + VkDeviceAddress r_ = c->dt->vkGetBufferDeviceAddress(device, pInfo); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkGetBufferMemoryRequirements(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkBuffer buffer; + vkb_dec_bytes(d, &buffer, sizeof(buffer)); + uint8_t has_pMemoryRequirements = vkb_dec_u8(d); + VkMemoryRequirements pMemoryRequirements_v; + memset(&pMemoryRequirements_v, 0, sizeof(pMemoryRequirements_v)); + VkMemoryRequirements *pMemoryRequirements = has_pMemoryRequirements ? &pMemoryRequirements_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetBufferMemoryRequirements) { vkb_srv_missing(c, "vkGetBufferMemoryRequirements"); return; } + c->dt->vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements); + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (pMemoryRequirements) vkb_enc_raw(e, pMemoryRequirements, sizeof(*pMemoryRequirements)); +} + +void vkb_sv_vkGetBufferMemoryRequirements2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkBufferMemoryRequirementsInfo2 *pInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferMemoryRequirementsInfo2 *a_ = (VkBufferMemoryRequirementsInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferMemoryRequirementsInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferMemoryRequirementsInfo2(d, &a_[i_]); + pInfo = a_; + } else { + pInfo = NULL; + } + uint8_t has_pMemoryRequirements = vkb_dec_u8(d); + VkMemoryRequirements2 pMemoryRequirements_v; + memset(&pMemoryRequirements_v, 0, sizeof(pMemoryRequirements_v)); + if (has_pMemoryRequirements) vkb_dec_out_template(d, &pMemoryRequirements_v, sizeof(VkMemoryRequirements2)); + VkMemoryRequirements2 *pMemoryRequirements = has_pMemoryRequirements ? &pMemoryRequirements_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetBufferMemoryRequirements2) { vkb_srv_missing(c, "vkGetBufferMemoryRequirements2"); return; } + c->dt->vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (pMemoryRequirements) vkb_enc_out_struct(e, pMemoryRequirements, sizeof(VkMemoryRequirements2)); +} + +void vkb_sv_vkGetBufferOpaqueCaptureAddress(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkBufferDeviceAddressInfo *pInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferDeviceAddressInfo *a_ = (VkBufferDeviceAddressInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferDeviceAddressInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferDeviceAddressInfo(d, &a_[i_]); + pInfo = a_; + } else { + pInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetBufferOpaqueCaptureAddress) { vkb_srv_missing(c, "vkGetBufferOpaqueCaptureAddress"); return; } + uint64_t r_ = c->dt->vkGetBufferOpaqueCaptureAddress(device, pInfo); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkGetCalibratedTimestampsEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + uint32_t timestampCount; + vkb_dec_bytes(d, ×tampCount, sizeof(timestampCount)); + const VkCalibratedTimestampInfoEXT *pTimestampInfos; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCalibratedTimestampInfoEXT *a_ = (VkCalibratedTimestampInfoEXT *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCalibratedTimestampInfoEXT)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkCalibratedTimestampInfoEXT(d, &a_[i_]); + pTimestampInfos = a_; + } else { + pTimestampInfos = NULL; + } + uint8_t has_pTimestamps = vkb_dec_u8(d); uint32_t n_pTimestamps = vkb_dec_u32(d); + uint64_t *pTimestamps = has_pTimestamps ? (uint64_t *)vkb_dec_alloc_zero(d, (size_t)n_pTimestamps * sizeof(uint64_t)) : NULL; + uint8_t has_pMaxDeviation = vkb_dec_u8(d); + uint64_t pMaxDeviation_v; + memset(&pMaxDeviation_v, 0, sizeof(pMaxDeviation_v)); + if (has_pMaxDeviation) vkb_dec_bytes(d, &pMaxDeviation_v, sizeof(pMaxDeviation_v)); + uint64_t *pMaxDeviation = has_pMaxDeviation ? &pMaxDeviation_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetCalibratedTimestampsEXT) { vkb_srv_missing(c, "vkGetCalibratedTimestampsEXT"); return; } + VkResult r_ = c->dt->vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + vkb_enc_bytes(e, &r_, sizeof(r_)); + { + uint32_t rn_ = n_pTimestamps; + uint32_t has_ = pTimestamps ? (rn_ < n_pTimestamps ? rn_ : n_pTimestamps) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &pTimestamps[i_], sizeof(uint64_t)); + } + vkb_enc_u8(e, pMaxDeviation != NULL); + if (pMaxDeviation) vkb_enc_raw(e, pMaxDeviation, sizeof(*pMaxDeviation)); +} + +void vkb_sv_vkGetDescriptorSetLayoutSupport(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkDescriptorSetLayoutCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDescriptorSetLayoutCreateInfo *a_ = (VkDescriptorSetLayoutCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDescriptorSetLayoutCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDescriptorSetLayoutCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pSupport = vkb_dec_u8(d); + VkDescriptorSetLayoutSupport pSupport_v; + memset(&pSupport_v, 0, sizeof(pSupport_v)); + if (has_pSupport) vkb_dec_out_template(d, &pSupport_v, sizeof(VkDescriptorSetLayoutSupport)); + VkDescriptorSetLayoutSupport *pSupport = has_pSupport ? &pSupport_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetDescriptorSetLayoutSupport) { vkb_srv_missing(c, "vkGetDescriptorSetLayoutSupport"); return; } + c->dt->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); + vkb_enc_u8(e, pSupport != NULL); + if (pSupport) vkb_enc_out_struct(e, pSupport, sizeof(VkDescriptorSetLayoutSupport)); +} + +void vkb_sv_vkGetDeviceBufferMemoryRequirements(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkDeviceBufferMemoryRequirements *pInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDeviceBufferMemoryRequirements *a_ = (VkDeviceBufferMemoryRequirements *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDeviceBufferMemoryRequirements)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDeviceBufferMemoryRequirements(d, &a_[i_]); + pInfo = a_; + } else { + pInfo = NULL; + } + uint8_t has_pMemoryRequirements = vkb_dec_u8(d); + VkMemoryRequirements2 pMemoryRequirements_v; + memset(&pMemoryRequirements_v, 0, sizeof(pMemoryRequirements_v)); + if (has_pMemoryRequirements) vkb_dec_out_template(d, &pMemoryRequirements_v, sizeof(VkMemoryRequirements2)); + VkMemoryRequirements2 *pMemoryRequirements = has_pMemoryRequirements ? &pMemoryRequirements_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetDeviceBufferMemoryRequirements) { vkb_srv_missing(c, "vkGetDeviceBufferMemoryRequirements"); return; } + c->dt->vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (pMemoryRequirements) vkb_enc_out_struct(e, pMemoryRequirements, sizeof(VkMemoryRequirements2)); +} + +void vkb_sv_vkGetDeviceGroupPeerMemoryFeatures(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + uint32_t heapIndex; + vkb_dec_bytes(d, &heapIndex, sizeof(heapIndex)); + uint32_t localDeviceIndex; + vkb_dec_bytes(d, &localDeviceIndex, sizeof(localDeviceIndex)); + uint32_t remoteDeviceIndex; + vkb_dec_bytes(d, &remoteDeviceIndex, sizeof(remoteDeviceIndex)); + uint8_t has_pPeerMemoryFeatures = vkb_dec_u8(d); + VkPeerMemoryFeatureFlags pPeerMemoryFeatures_v; + memset(&pPeerMemoryFeatures_v, 0, sizeof(pPeerMemoryFeatures_v)); + if (has_pPeerMemoryFeatures) vkb_dec_bytes(d, &pPeerMemoryFeatures_v, sizeof(pPeerMemoryFeatures_v)); + VkPeerMemoryFeatureFlags *pPeerMemoryFeatures = has_pPeerMemoryFeatures ? &pPeerMemoryFeatures_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetDeviceGroupPeerMemoryFeatures) { vkb_srv_missing(c, "vkGetDeviceGroupPeerMemoryFeatures"); return; } + c->dt->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + vkb_enc_u8(e, pPeerMemoryFeatures != NULL); + if (pPeerMemoryFeatures) vkb_enc_raw(e, pPeerMemoryFeatures, sizeof(*pPeerMemoryFeatures)); +} + +void vkb_sv_vkGetDeviceImageMemoryRequirements(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkDeviceImageMemoryRequirements *pInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDeviceImageMemoryRequirements *a_ = (VkDeviceImageMemoryRequirements *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDeviceImageMemoryRequirements)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDeviceImageMemoryRequirements(d, &a_[i_]); + pInfo = a_; + } else { + pInfo = NULL; + } + uint8_t has_pMemoryRequirements = vkb_dec_u8(d); + VkMemoryRequirements2 pMemoryRequirements_v; + memset(&pMemoryRequirements_v, 0, sizeof(pMemoryRequirements_v)); + if (has_pMemoryRequirements) vkb_dec_out_template(d, &pMemoryRequirements_v, sizeof(VkMemoryRequirements2)); + VkMemoryRequirements2 *pMemoryRequirements = has_pMemoryRequirements ? &pMemoryRequirements_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetDeviceImageMemoryRequirements) { vkb_srv_missing(c, "vkGetDeviceImageMemoryRequirements"); return; } + c->dt->vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (pMemoryRequirements) vkb_enc_out_struct(e, pMemoryRequirements, sizeof(VkMemoryRequirements2)); +} + +void vkb_sv_vkGetDeviceImageSparseMemoryRequirements(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkDeviceImageMemoryRequirements *pInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDeviceImageMemoryRequirements *a_ = (VkDeviceImageMemoryRequirements *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDeviceImageMemoryRequirements)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDeviceImageMemoryRequirements(d, &a_[i_]); + pInfo = a_; + } else { + pInfo = NULL; + } + uint8_t has_pSparseMemoryRequirementCount = vkb_dec_u8(d); + uint32_t pSparseMemoryRequirementCount_v; + memset(&pSparseMemoryRequirementCount_v, 0, sizeof(pSparseMemoryRequirementCount_v)); + if (has_pSparseMemoryRequirementCount) vkb_dec_bytes(d, &pSparseMemoryRequirementCount_v, sizeof(pSparseMemoryRequirementCount_v)); + uint32_t *pSparseMemoryRequirementCount = has_pSparseMemoryRequirementCount ? &pSparseMemoryRequirementCount_v : NULL; + uint8_t has_pSparseMemoryRequirements = vkb_dec_u8(d); uint32_t n_pSparseMemoryRequirements = vkb_dec_u32(d); + VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements = has_pSparseMemoryRequirements ? (VkSparseImageMemoryRequirements2 *)vkb_dec_alloc_zero(d, (size_t)n_pSparseMemoryRequirements * sizeof(VkSparseImageMemoryRequirements2)) : NULL; + for (uint32_t i_ = 0; pSparseMemoryRequirements && i_ < n_pSparseMemoryRequirements; i_++) vkb_dec_out_template(d, &pSparseMemoryRequirements[i_], sizeof(VkSparseImageMemoryRequirements2)); + if (pSparseMemoryRequirements && pSparseMemoryRequirementCount) *pSparseMemoryRequirementCount = n_pSparseMemoryRequirements; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetDeviceImageSparseMemoryRequirements) { vkb_srv_missing(c, "vkGetDeviceImageSparseMemoryRequirements"); return; } + c->dt->vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + vkb_enc_u8(e, pSparseMemoryRequirementCount != NULL); + if (pSparseMemoryRequirementCount) vkb_enc_raw(e, pSparseMemoryRequirementCount, sizeof(*pSparseMemoryRequirementCount)); + { + uint32_t rn_ = (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); + uint32_t has_ = pSparseMemoryRequirements ? (rn_ < n_pSparseMemoryRequirements ? rn_ : n_pSparseMemoryRequirements) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_out_struct(e, &pSparseMemoryRequirements[i_], sizeof(VkSparseImageMemoryRequirements2)); + } +} + +void vkb_sv_vkGetDeviceMemoryCommitment(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkDeviceMemory memory; + vkb_dec_bytes(d, &memory, sizeof(memory)); + uint8_t has_pCommittedMemoryInBytes = vkb_dec_u8(d); + VkDeviceSize pCommittedMemoryInBytes_v; + memset(&pCommittedMemoryInBytes_v, 0, sizeof(pCommittedMemoryInBytes_v)); + if (has_pCommittedMemoryInBytes) vkb_dec_bytes(d, &pCommittedMemoryInBytes_v, sizeof(pCommittedMemoryInBytes_v)); + VkDeviceSize *pCommittedMemoryInBytes = has_pCommittedMemoryInBytes ? &pCommittedMemoryInBytes_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetDeviceMemoryCommitment) { vkb_srv_missing(c, "vkGetDeviceMemoryCommitment"); return; } + c->dt->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); + vkb_enc_u8(e, pCommittedMemoryInBytes != NULL); + if (pCommittedMemoryInBytes) vkb_enc_raw(e, pCommittedMemoryInBytes, sizeof(*pCommittedMemoryInBytes)); +} + +void vkb_sv_vkGetDeviceMemoryOpaqueCaptureAddress(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDeviceMemoryOpaqueCaptureAddressInfo *a_ = (VkDeviceMemoryOpaqueCaptureAddressInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDeviceMemoryOpaqueCaptureAddressInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDeviceMemoryOpaqueCaptureAddressInfo(d, &a_[i_]); + pInfo = a_; + } else { + pInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetDeviceMemoryOpaqueCaptureAddress) { vkb_srv_missing(c, "vkGetDeviceMemoryOpaqueCaptureAddress"); return; } + uint64_t r_ = c->dt->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkGetDeviceQueue(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + uint32_t queueFamilyIndex; + vkb_dec_bytes(d, &queueFamilyIndex, sizeof(queueFamilyIndex)); + uint32_t queueIndex; + vkb_dec_bytes(d, &queueIndex, sizeof(queueIndex)); + uint8_t has_pQueue = vkb_dec_u8(d); + VkQueue pQueue_v; + memset(&pQueue_v, 0, sizeof(pQueue_v)); + VkQueue *pQueue = has_pQueue ? &pQueue_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetDeviceQueue) { vkb_srv_missing(c, "vkGetDeviceQueue"); return; } + c->dt->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); + vkb_enc_u8(e, pQueue != NULL); + if (pQueue) vkb_enc_u64(e, (uint64_t)(uintptr_t)*pQueue); +} + +void vkb_sv_vkGetDeviceQueue2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkDeviceQueueInfo2 *pQueueInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDeviceQueueInfo2 *a_ = (VkDeviceQueueInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDeviceQueueInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDeviceQueueInfo2(d, &a_[i_]); + pQueueInfo = a_; + } else { + pQueueInfo = NULL; + } + uint8_t has_pQueue = vkb_dec_u8(d); + VkQueue pQueue_v; + memset(&pQueue_v, 0, sizeof(pQueue_v)); + VkQueue *pQueue = has_pQueue ? &pQueue_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetDeviceQueue2) { vkb_srv_missing(c, "vkGetDeviceQueue2"); return; } + c->dt->vkGetDeviceQueue2(device, pQueueInfo, pQueue); + vkb_enc_u8(e, pQueue != NULL); + if (pQueue) vkb_enc_u64(e, (uint64_t)(uintptr_t)*pQueue); +} + +void vkb_sv_vkGetEventStatus(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkEvent event; + vkb_dec_bytes(d, &event, sizeof(event)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetEventStatus) { vkb_srv_missing(c, "vkGetEventStatus"); return; } + VkResult r_ = c->dt->vkGetEventStatus(device, event); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkGetFenceFdKHR(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkFenceGetFdInfoKHR *pGetFdInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkFenceGetFdInfoKHR *a_ = (VkFenceGetFdInfoKHR *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkFenceGetFdInfoKHR)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkFenceGetFdInfoKHR(d, &a_[i_]); + pGetFdInfo = a_; + } else { + pGetFdInfo = NULL; + } + int pFd_v = -1; int *pFd = vkb_dec_u8(d) ? &pFd_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetFenceFdKHR) { vkb_srv_missing(c, "vkGetFenceFdKHR"); return; } + VkResult r_ = c->dt->vkGetFenceFdKHR(device, pGetFdInfo, pFd); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_fd(e, pFd ? *pFd : -1); + if (pFd && *pFd >= 0) vkb_srv_close_after_send(c, *pFd); +} + +void vkb_sv_vkGetFenceStatus(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkFence fence; + vkb_dec_bytes(d, &fence, sizeof(fence)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetFenceStatus) { vkb_srv_missing(c, "vkGetFenceStatus"); return; } + VkResult r_ = c->dt->vkGetFenceStatus(device, fence); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkGetImageDrmFormatModifierPropertiesEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkImage image; + vkb_dec_bytes(d, &image, sizeof(image)); + uint8_t has_pProperties = vkb_dec_u8(d); + VkImageDrmFormatModifierPropertiesEXT pProperties_v; + memset(&pProperties_v, 0, sizeof(pProperties_v)); + if (has_pProperties) vkb_dec_out_template(d, &pProperties_v, sizeof(VkImageDrmFormatModifierPropertiesEXT)); + VkImageDrmFormatModifierPropertiesEXT *pProperties = has_pProperties ? &pProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetImageDrmFormatModifierPropertiesEXT) { vkb_srv_missing(c, "vkGetImageDrmFormatModifierPropertiesEXT"); return; } + VkResult r_ = c->dt->vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pProperties != NULL); + if (pProperties) vkb_enc_out_struct(e, pProperties, sizeof(VkImageDrmFormatModifierPropertiesEXT)); +} + +void vkb_sv_vkGetImageMemoryRequirements(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkImage image; + vkb_dec_bytes(d, &image, sizeof(image)); + uint8_t has_pMemoryRequirements = vkb_dec_u8(d); + VkMemoryRequirements pMemoryRequirements_v; + memset(&pMemoryRequirements_v, 0, sizeof(pMemoryRequirements_v)); + VkMemoryRequirements *pMemoryRequirements = has_pMemoryRequirements ? &pMemoryRequirements_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetImageMemoryRequirements) { vkb_srv_missing(c, "vkGetImageMemoryRequirements"); return; } + c->dt->vkGetImageMemoryRequirements(device, image, pMemoryRequirements); + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (pMemoryRequirements) vkb_enc_raw(e, pMemoryRequirements, sizeof(*pMemoryRequirements)); +} + +void vkb_sv_vkGetImageMemoryRequirements2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkImageMemoryRequirementsInfo2 *pInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageMemoryRequirementsInfo2 *a_ = (VkImageMemoryRequirementsInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageMemoryRequirementsInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageMemoryRequirementsInfo2(d, &a_[i_]); + pInfo = a_; + } else { + pInfo = NULL; + } + uint8_t has_pMemoryRequirements = vkb_dec_u8(d); + VkMemoryRequirements2 pMemoryRequirements_v; + memset(&pMemoryRequirements_v, 0, sizeof(pMemoryRequirements_v)); + if (has_pMemoryRequirements) vkb_dec_out_template(d, &pMemoryRequirements_v, sizeof(VkMemoryRequirements2)); + VkMemoryRequirements2 *pMemoryRequirements = has_pMemoryRequirements ? &pMemoryRequirements_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetImageMemoryRequirements2) { vkb_srv_missing(c, "vkGetImageMemoryRequirements2"); return; } + c->dt->vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); + vkb_enc_u8(e, pMemoryRequirements != NULL); + if (pMemoryRequirements) vkb_enc_out_struct(e, pMemoryRequirements, sizeof(VkMemoryRequirements2)); +} + +void vkb_sv_vkGetImageSparseMemoryRequirements(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkImage image; + vkb_dec_bytes(d, &image, sizeof(image)); + uint8_t has_pSparseMemoryRequirementCount = vkb_dec_u8(d); + uint32_t pSparseMemoryRequirementCount_v; + memset(&pSparseMemoryRequirementCount_v, 0, sizeof(pSparseMemoryRequirementCount_v)); + if (has_pSparseMemoryRequirementCount) vkb_dec_bytes(d, &pSparseMemoryRequirementCount_v, sizeof(pSparseMemoryRequirementCount_v)); + uint32_t *pSparseMemoryRequirementCount = has_pSparseMemoryRequirementCount ? &pSparseMemoryRequirementCount_v : NULL; + uint8_t has_pSparseMemoryRequirements = vkb_dec_u8(d); uint32_t n_pSparseMemoryRequirements = vkb_dec_u32(d); + VkSparseImageMemoryRequirements *pSparseMemoryRequirements = has_pSparseMemoryRequirements ? (VkSparseImageMemoryRequirements *)vkb_dec_alloc_zero(d, (size_t)n_pSparseMemoryRequirements * sizeof(VkSparseImageMemoryRequirements)) : NULL; + if (pSparseMemoryRequirements && pSparseMemoryRequirementCount) *pSparseMemoryRequirementCount = n_pSparseMemoryRequirements; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetImageSparseMemoryRequirements) { vkb_srv_missing(c, "vkGetImageSparseMemoryRequirements"); return; } + c->dt->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + vkb_enc_u8(e, pSparseMemoryRequirementCount != NULL); + if (pSparseMemoryRequirementCount) vkb_enc_raw(e, pSparseMemoryRequirementCount, sizeof(*pSparseMemoryRequirementCount)); + { + uint32_t rn_ = (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); + uint32_t has_ = pSparseMemoryRequirements ? (rn_ < n_pSparseMemoryRequirements ? rn_ : n_pSparseMemoryRequirements) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &pSparseMemoryRequirements[i_], sizeof(VkSparseImageMemoryRequirements)); + } +} + +void vkb_sv_vkGetImageSparseMemoryRequirements2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkImageSparseMemoryRequirementsInfo2 *pInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageSparseMemoryRequirementsInfo2 *a_ = (VkImageSparseMemoryRequirementsInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageSparseMemoryRequirementsInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageSparseMemoryRequirementsInfo2(d, &a_[i_]); + pInfo = a_; + } else { + pInfo = NULL; + } + uint8_t has_pSparseMemoryRequirementCount = vkb_dec_u8(d); + uint32_t pSparseMemoryRequirementCount_v; + memset(&pSparseMemoryRequirementCount_v, 0, sizeof(pSparseMemoryRequirementCount_v)); + if (has_pSparseMemoryRequirementCount) vkb_dec_bytes(d, &pSparseMemoryRequirementCount_v, sizeof(pSparseMemoryRequirementCount_v)); + uint32_t *pSparseMemoryRequirementCount = has_pSparseMemoryRequirementCount ? &pSparseMemoryRequirementCount_v : NULL; + uint8_t has_pSparseMemoryRequirements = vkb_dec_u8(d); uint32_t n_pSparseMemoryRequirements = vkb_dec_u32(d); + VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements = has_pSparseMemoryRequirements ? (VkSparseImageMemoryRequirements2 *)vkb_dec_alloc_zero(d, (size_t)n_pSparseMemoryRequirements * sizeof(VkSparseImageMemoryRequirements2)) : NULL; + for (uint32_t i_ = 0; pSparseMemoryRequirements && i_ < n_pSparseMemoryRequirements; i_++) vkb_dec_out_template(d, &pSparseMemoryRequirements[i_], sizeof(VkSparseImageMemoryRequirements2)); + if (pSparseMemoryRequirements && pSparseMemoryRequirementCount) *pSparseMemoryRequirementCount = n_pSparseMemoryRequirements; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetImageSparseMemoryRequirements2) { vkb_srv_missing(c, "vkGetImageSparseMemoryRequirements2"); return; } + c->dt->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + vkb_enc_u8(e, pSparseMemoryRequirementCount != NULL); + if (pSparseMemoryRequirementCount) vkb_enc_raw(e, pSparseMemoryRequirementCount, sizeof(*pSparseMemoryRequirementCount)); + { + uint32_t rn_ = (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); + uint32_t has_ = pSparseMemoryRequirements ? (rn_ < n_pSparseMemoryRequirements ? rn_ : n_pSparseMemoryRequirements) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_out_struct(e, &pSparseMemoryRequirements[i_], sizeof(VkSparseImageMemoryRequirements2)); + } +} + +void vkb_sv_vkGetImageSubresourceLayout(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkImage image; + vkb_dec_bytes(d, &image, sizeof(image)); + const VkImageSubresource *pSubresource; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pSubresource = (const VkImageSubresource *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkImageSubresource)); + } else { + pSubresource = NULL; + } + uint8_t has_pLayout = vkb_dec_u8(d); + VkSubresourceLayout pLayout_v; + memset(&pLayout_v, 0, sizeof(pLayout_v)); + VkSubresourceLayout *pLayout = has_pLayout ? &pLayout_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetImageSubresourceLayout) { vkb_srv_missing(c, "vkGetImageSubresourceLayout"); return; } + c->dt->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout); + vkb_enc_u8(e, pLayout != NULL); + if (pLayout) vkb_enc_raw(e, pLayout, sizeof(*pLayout)); +} + +void vkb_sv_vkGetImageSubresourceLayout2EXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkImage image; + vkb_dec_bytes(d, &image, sizeof(image)); + const VkImageSubresource2EXT *pSubresource; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageSubresource2EXT *a_ = (VkImageSubresource2EXT *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageSubresource2EXT)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageSubresource2EXT(d, &a_[i_]); + pSubresource = a_; + } else { + pSubresource = NULL; + } + uint8_t has_pLayout = vkb_dec_u8(d); + VkSubresourceLayout2EXT pLayout_v; + memset(&pLayout_v, 0, sizeof(pLayout_v)); + if (has_pLayout) vkb_dec_out_template(d, &pLayout_v, sizeof(VkSubresourceLayout2EXT)); + VkSubresourceLayout2EXT *pLayout = has_pLayout ? &pLayout_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetImageSubresourceLayout2EXT) { vkb_srv_missing(c, "vkGetImageSubresourceLayout2EXT"); return; } + c->dt->vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout); + vkb_enc_u8(e, pLayout != NULL); + if (pLayout) vkb_enc_out_struct(e, pLayout, sizeof(VkSubresourceLayout2EXT)); +} + +void vkb_sv_vkGetMemoryFdKHR(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkMemoryGetFdInfoKHR *pGetFdInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkMemoryGetFdInfoKHR *a_ = (VkMemoryGetFdInfoKHR *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkMemoryGetFdInfoKHR)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkMemoryGetFdInfoKHR(d, &a_[i_]); + pGetFdInfo = a_; + } else { + pGetFdInfo = NULL; + } + int pFd_v = -1; int *pFd = vkb_dec_u8(d) ? &pFd_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetMemoryFdKHR) { vkb_srv_missing(c, "vkGetMemoryFdKHR"); return; } + VkResult r_ = c->dt->vkGetMemoryFdKHR(device, pGetFdInfo, pFd); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_fd(e, pFd ? *pFd : -1); + if (pFd && *pFd >= 0) vkb_srv_close_after_send(c, *pFd); +} + +void vkb_sv_vkGetMemoryFdPropertiesKHR(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkExternalMemoryHandleTypeFlagBits handleType; + vkb_dec_bytes(d, &handleType, sizeof(handleType)); + int fd = vkb_dec_fd(d); + uint8_t has_pMemoryFdProperties = vkb_dec_u8(d); + VkMemoryFdPropertiesKHR pMemoryFdProperties_v; + memset(&pMemoryFdProperties_v, 0, sizeof(pMemoryFdProperties_v)); + if (has_pMemoryFdProperties) vkb_dec_out_template(d, &pMemoryFdProperties_v, sizeof(VkMemoryFdPropertiesKHR)); + VkMemoryFdPropertiesKHR *pMemoryFdProperties = has_pMemoryFdProperties ? &pMemoryFdProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetMemoryFdPropertiesKHR) { vkb_srv_missing(c, "vkGetMemoryFdPropertiesKHR"); return; } + VkResult r_ = c->dt->vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); + vkb_enc_bytes(e, &r_, sizeof(r_)); + if (fd >= 0) vkb_close_fd(fd); + vkb_enc_u8(e, pMemoryFdProperties != NULL); + if (pMemoryFdProperties) vkb_enc_out_struct(e, pMemoryFdProperties, sizeof(VkMemoryFdPropertiesKHR)); +} + +void vkb_sv_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pTimeDomainCount = vkb_dec_u8(d); + uint32_t pTimeDomainCount_v; + memset(&pTimeDomainCount_v, 0, sizeof(pTimeDomainCount_v)); + if (has_pTimeDomainCount) vkb_dec_bytes(d, &pTimeDomainCount_v, sizeof(pTimeDomainCount_v)); + uint32_t *pTimeDomainCount = has_pTimeDomainCount ? &pTimeDomainCount_v : NULL; + uint8_t has_pTimeDomains = vkb_dec_u8(d); uint32_t n_pTimeDomains = vkb_dec_u32(d); + VkTimeDomainEXT *pTimeDomains = has_pTimeDomains ? (VkTimeDomainEXT *)vkb_dec_alloc_zero(d, (size_t)n_pTimeDomains * sizeof(VkTimeDomainEXT)) : NULL; + if (pTimeDomains && pTimeDomainCount) *pTimeDomainCount = n_pTimeDomains; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT) { vkb_srv_missing(c, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"); return; } + VkResult r_ = c->dt->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pTimeDomainCount != NULL); + if (pTimeDomainCount) vkb_enc_raw(e, pTimeDomainCount, sizeof(*pTimeDomainCount)); + { + uint32_t rn_ = (pTimeDomainCount ? *pTimeDomainCount : 0); + uint32_t has_ = pTimeDomains ? (rn_ < n_pTimeDomains ? rn_ : n_pTimeDomains) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &pTimeDomains[i_], sizeof(VkTimeDomainEXT)); + } +} + +void vkb_sv_vkGetPhysicalDeviceExternalBufferProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPhysicalDeviceExternalBufferInfo *a_ = (VkPhysicalDeviceExternalBufferInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPhysicalDeviceExternalBufferInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPhysicalDeviceExternalBufferInfo(d, &a_[i_]); + pExternalBufferInfo = a_; + } else { + pExternalBufferInfo = NULL; + } + uint8_t has_pExternalBufferProperties = vkb_dec_u8(d); + VkExternalBufferProperties pExternalBufferProperties_v; + memset(&pExternalBufferProperties_v, 0, sizeof(pExternalBufferProperties_v)); + if (has_pExternalBufferProperties) vkb_dec_out_template(d, &pExternalBufferProperties_v, sizeof(VkExternalBufferProperties)); + VkExternalBufferProperties *pExternalBufferProperties = has_pExternalBufferProperties ? &pExternalBufferProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceExternalBufferProperties) { vkb_srv_missing(c, "vkGetPhysicalDeviceExternalBufferProperties"); return; } + c->dt->vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + vkb_enc_u8(e, pExternalBufferProperties != NULL); + if (pExternalBufferProperties) vkb_enc_out_struct(e, pExternalBufferProperties, sizeof(VkExternalBufferProperties)); +} + +void vkb_sv_vkGetPhysicalDeviceExternalFenceProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPhysicalDeviceExternalFenceInfo *a_ = (VkPhysicalDeviceExternalFenceInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPhysicalDeviceExternalFenceInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPhysicalDeviceExternalFenceInfo(d, &a_[i_]); + pExternalFenceInfo = a_; + } else { + pExternalFenceInfo = NULL; + } + uint8_t has_pExternalFenceProperties = vkb_dec_u8(d); + VkExternalFenceProperties pExternalFenceProperties_v; + memset(&pExternalFenceProperties_v, 0, sizeof(pExternalFenceProperties_v)); + if (has_pExternalFenceProperties) vkb_dec_out_template(d, &pExternalFenceProperties_v, sizeof(VkExternalFenceProperties)); + VkExternalFenceProperties *pExternalFenceProperties = has_pExternalFenceProperties ? &pExternalFenceProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceExternalFenceProperties) { vkb_srv_missing(c, "vkGetPhysicalDeviceExternalFenceProperties"); return; } + c->dt->vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + vkb_enc_u8(e, pExternalFenceProperties != NULL); + if (pExternalFenceProperties) vkb_enc_out_struct(e, pExternalFenceProperties, sizeof(VkExternalFenceProperties)); +} + +void vkb_sv_vkGetPhysicalDeviceExternalSemaphoreProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPhysicalDeviceExternalSemaphoreInfo *a_ = (VkPhysicalDeviceExternalSemaphoreInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPhysicalDeviceExternalSemaphoreInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPhysicalDeviceExternalSemaphoreInfo(d, &a_[i_]); + pExternalSemaphoreInfo = a_; + } else { + pExternalSemaphoreInfo = NULL; + } + uint8_t has_pExternalSemaphoreProperties = vkb_dec_u8(d); + VkExternalSemaphoreProperties pExternalSemaphoreProperties_v; + memset(&pExternalSemaphoreProperties_v, 0, sizeof(pExternalSemaphoreProperties_v)); + if (has_pExternalSemaphoreProperties) vkb_dec_out_template(d, &pExternalSemaphoreProperties_v, sizeof(VkExternalSemaphoreProperties)); + VkExternalSemaphoreProperties *pExternalSemaphoreProperties = has_pExternalSemaphoreProperties ? &pExternalSemaphoreProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceExternalSemaphoreProperties) { vkb_srv_missing(c, "vkGetPhysicalDeviceExternalSemaphoreProperties"); return; } + c->dt->vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + vkb_enc_u8(e, pExternalSemaphoreProperties != NULL); + if (pExternalSemaphoreProperties) vkb_enc_out_struct(e, pExternalSemaphoreProperties, sizeof(VkExternalSemaphoreProperties)); +} + +void vkb_sv_vkGetPhysicalDeviceFeatures(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pFeatures = vkb_dec_u8(d); + VkPhysicalDeviceFeatures pFeatures_v; + memset(&pFeatures_v, 0, sizeof(pFeatures_v)); + VkPhysicalDeviceFeatures *pFeatures = has_pFeatures ? &pFeatures_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceFeatures) { vkb_srv_missing(c, "vkGetPhysicalDeviceFeatures"); return; } + c->dt->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures); + vkb_enc_u8(e, pFeatures != NULL); + if (pFeatures) vkb_enc_raw(e, pFeatures, sizeof(*pFeatures)); +} + +void vkb_sv_vkGetPhysicalDeviceFeatures2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pFeatures = vkb_dec_u8(d); + VkPhysicalDeviceFeatures2 pFeatures_v; + memset(&pFeatures_v, 0, sizeof(pFeatures_v)); + if (has_pFeatures) vkb_dec_out_template(d, &pFeatures_v, sizeof(VkPhysicalDeviceFeatures2)); + VkPhysicalDeviceFeatures2 *pFeatures = has_pFeatures ? &pFeatures_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceFeatures2) { vkb_srv_missing(c, "vkGetPhysicalDeviceFeatures2"); return; } + c->dt->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures); + vkb_enc_u8(e, pFeatures != NULL); + if (pFeatures) vkb_enc_out_struct(e, pFeatures, sizeof(VkPhysicalDeviceFeatures2)); +} + +void vkb_sv_vkGetPhysicalDeviceFormatProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + VkFormat format; + vkb_dec_bytes(d, &format, sizeof(format)); + uint8_t has_pFormatProperties = vkb_dec_u8(d); + VkFormatProperties pFormatProperties_v; + memset(&pFormatProperties_v, 0, sizeof(pFormatProperties_v)); + VkFormatProperties *pFormatProperties = has_pFormatProperties ? &pFormatProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceFormatProperties) { vkb_srv_missing(c, "vkGetPhysicalDeviceFormatProperties"); return; } + c->dt->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); + vkb_enc_u8(e, pFormatProperties != NULL); + if (pFormatProperties) vkb_enc_raw(e, pFormatProperties, sizeof(*pFormatProperties)); +} + +void vkb_sv_vkGetPhysicalDeviceFormatProperties2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + VkFormat format; + vkb_dec_bytes(d, &format, sizeof(format)); + uint8_t has_pFormatProperties = vkb_dec_u8(d); + VkFormatProperties2 pFormatProperties_v; + memset(&pFormatProperties_v, 0, sizeof(pFormatProperties_v)); + if (has_pFormatProperties) vkb_dec_out_template(d, &pFormatProperties_v, sizeof(VkFormatProperties2)); + VkFormatProperties2 *pFormatProperties = has_pFormatProperties ? &pFormatProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceFormatProperties2) { vkb_srv_missing(c, "vkGetPhysicalDeviceFormatProperties2"); return; } + c->dt->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); + vkb_enc_u8(e, pFormatProperties != NULL); + if (pFormatProperties) vkb_enc_out_struct(e, pFormatProperties, sizeof(VkFormatProperties2)); +} + +void vkb_sv_vkGetPhysicalDeviceFragmentShadingRatesKHR(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pFragmentShadingRateCount = vkb_dec_u8(d); + uint32_t pFragmentShadingRateCount_v; + memset(&pFragmentShadingRateCount_v, 0, sizeof(pFragmentShadingRateCount_v)); + if (has_pFragmentShadingRateCount) vkb_dec_bytes(d, &pFragmentShadingRateCount_v, sizeof(pFragmentShadingRateCount_v)); + uint32_t *pFragmentShadingRateCount = has_pFragmentShadingRateCount ? &pFragmentShadingRateCount_v : NULL; + uint8_t has_pFragmentShadingRates = vkb_dec_u8(d); uint32_t n_pFragmentShadingRates = vkb_dec_u32(d); + VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates = has_pFragmentShadingRates ? (VkPhysicalDeviceFragmentShadingRateKHR *)vkb_dec_alloc_zero(d, (size_t)n_pFragmentShadingRates * sizeof(VkPhysicalDeviceFragmentShadingRateKHR)) : NULL; + for (uint32_t i_ = 0; pFragmentShadingRates && i_ < n_pFragmentShadingRates; i_++) vkb_dec_out_template(d, &pFragmentShadingRates[i_], sizeof(VkPhysicalDeviceFragmentShadingRateKHR)); + if (pFragmentShadingRates && pFragmentShadingRateCount) *pFragmentShadingRateCount = n_pFragmentShadingRates; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceFragmentShadingRatesKHR) { vkb_srv_missing(c, "vkGetPhysicalDeviceFragmentShadingRatesKHR"); return; } + VkResult r_ = c->dt->vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pFragmentShadingRateCount != NULL); + if (pFragmentShadingRateCount) vkb_enc_raw(e, pFragmentShadingRateCount, sizeof(*pFragmentShadingRateCount)); + { + uint32_t rn_ = (pFragmentShadingRateCount ? *pFragmentShadingRateCount : 0); + uint32_t has_ = pFragmentShadingRates ? (rn_ < n_pFragmentShadingRates ? rn_ : n_pFragmentShadingRates) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_out_struct(e, &pFragmentShadingRates[i_], sizeof(VkPhysicalDeviceFragmentShadingRateKHR)); + } +} + +void vkb_sv_vkGetPhysicalDeviceImageFormatProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + VkFormat format; + vkb_dec_bytes(d, &format, sizeof(format)); + VkImageType type; + vkb_dec_bytes(d, &type, sizeof(type)); + VkImageTiling tiling; + vkb_dec_bytes(d, &tiling, sizeof(tiling)); + VkImageUsageFlags usage; + vkb_dec_bytes(d, &usage, sizeof(usage)); + VkImageCreateFlags flags; + vkb_dec_bytes(d, &flags, sizeof(flags)); + uint8_t has_pImageFormatProperties = vkb_dec_u8(d); + VkImageFormatProperties pImageFormatProperties_v; + memset(&pImageFormatProperties_v, 0, sizeof(pImageFormatProperties_v)); + VkImageFormatProperties *pImageFormatProperties = has_pImageFormatProperties ? &pImageFormatProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceImageFormatProperties) { vkb_srv_missing(c, "vkGetPhysicalDeviceImageFormatProperties"); return; } + VkResult r_ = c->dt->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pImageFormatProperties != NULL); + if (pImageFormatProperties) vkb_enc_raw(e, pImageFormatProperties, sizeof(*pImageFormatProperties)); +} + +void vkb_sv_vkGetPhysicalDeviceImageFormatProperties2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPhysicalDeviceImageFormatInfo2 *a_ = (VkPhysicalDeviceImageFormatInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPhysicalDeviceImageFormatInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPhysicalDeviceImageFormatInfo2(d, &a_[i_]); + pImageFormatInfo = a_; + } else { + pImageFormatInfo = NULL; + } + uint8_t has_pImageFormatProperties = vkb_dec_u8(d); + VkImageFormatProperties2 pImageFormatProperties_v; + memset(&pImageFormatProperties_v, 0, sizeof(pImageFormatProperties_v)); + if (has_pImageFormatProperties) vkb_dec_out_template(d, &pImageFormatProperties_v, sizeof(VkImageFormatProperties2)); + VkImageFormatProperties2 *pImageFormatProperties = has_pImageFormatProperties ? &pImageFormatProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceImageFormatProperties2) { vkb_srv_missing(c, "vkGetPhysicalDeviceImageFormatProperties2"); return; } + VkResult r_ = c->dt->vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pImageFormatProperties != NULL); + if (pImageFormatProperties) vkb_enc_out_struct(e, pImageFormatProperties, sizeof(VkImageFormatProperties2)); +} + +void vkb_sv_vkGetPhysicalDeviceMemoryProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pMemoryProperties = vkb_dec_u8(d); + VkPhysicalDeviceMemoryProperties pMemoryProperties_v; + memset(&pMemoryProperties_v, 0, sizeof(pMemoryProperties_v)); + VkPhysicalDeviceMemoryProperties *pMemoryProperties = has_pMemoryProperties ? &pMemoryProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceMemoryProperties) { vkb_srv_missing(c, "vkGetPhysicalDeviceMemoryProperties"); return; } + c->dt->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); + vkb_enc_u8(e, pMemoryProperties != NULL); + if (pMemoryProperties) vkb_enc_raw(e, pMemoryProperties, sizeof(*pMemoryProperties)); +} + +void vkb_sv_vkGetPhysicalDeviceMemoryProperties2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pMemoryProperties = vkb_dec_u8(d); + VkPhysicalDeviceMemoryProperties2 pMemoryProperties_v; + memset(&pMemoryProperties_v, 0, sizeof(pMemoryProperties_v)); + if (has_pMemoryProperties) vkb_dec_out_template(d, &pMemoryProperties_v, sizeof(VkPhysicalDeviceMemoryProperties2)); + VkPhysicalDeviceMemoryProperties2 *pMemoryProperties = has_pMemoryProperties ? &pMemoryProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceMemoryProperties2) { vkb_srv_missing(c, "vkGetPhysicalDeviceMemoryProperties2"); return; } + c->dt->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); + vkb_enc_u8(e, pMemoryProperties != NULL); + if (pMemoryProperties) vkb_enc_out_struct(e, pMemoryProperties, sizeof(VkPhysicalDeviceMemoryProperties2)); +} + +void vkb_sv_vkGetPhysicalDeviceMultisamplePropertiesEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + VkSampleCountFlagBits samples; + vkb_dec_bytes(d, &samples, sizeof(samples)); + uint8_t has_pMultisampleProperties = vkb_dec_u8(d); + VkMultisamplePropertiesEXT pMultisampleProperties_v; + memset(&pMultisampleProperties_v, 0, sizeof(pMultisampleProperties_v)); + if (has_pMultisampleProperties) vkb_dec_out_template(d, &pMultisampleProperties_v, sizeof(VkMultisamplePropertiesEXT)); + VkMultisamplePropertiesEXT *pMultisampleProperties = has_pMultisampleProperties ? &pMultisampleProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceMultisamplePropertiesEXT) { vkb_srv_missing(c, "vkGetPhysicalDeviceMultisamplePropertiesEXT"); return; } + c->dt->vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); + vkb_enc_u8(e, pMultisampleProperties != NULL); + if (pMultisampleProperties) vkb_enc_out_struct(e, pMultisampleProperties, sizeof(VkMultisamplePropertiesEXT)); +} + +void vkb_sv_vkGetPhysicalDeviceProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pProperties = vkb_dec_u8(d); + VkPhysicalDeviceProperties pProperties_v; + memset(&pProperties_v, 0, sizeof(pProperties_v)); + VkPhysicalDeviceProperties *pProperties = has_pProperties ? &pProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceProperties) { vkb_srv_missing(c, "vkGetPhysicalDeviceProperties"); return; } + c->dt->vkGetPhysicalDeviceProperties(physicalDevice, pProperties); + vkb_enc_u8(e, pProperties != NULL); + if (pProperties) vkb_enc_raw(e, pProperties, sizeof(*pProperties)); +} + +void vkb_sv_vkGetPhysicalDeviceProperties2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pProperties = vkb_dec_u8(d); + VkPhysicalDeviceProperties2 pProperties_v; + memset(&pProperties_v, 0, sizeof(pProperties_v)); + if (has_pProperties) vkb_dec_out_template(d, &pProperties_v, sizeof(VkPhysicalDeviceProperties2)); + VkPhysicalDeviceProperties2 *pProperties = has_pProperties ? &pProperties_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceProperties2) { vkb_srv_missing(c, "vkGetPhysicalDeviceProperties2"); return; } + c->dt->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties); + vkb_enc_u8(e, pProperties != NULL); + if (pProperties) vkb_enc_out_struct(e, pProperties, sizeof(VkPhysicalDeviceProperties2)); +} + +void vkb_sv_vkGetPhysicalDeviceQueueFamilyProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pQueueFamilyPropertyCount = vkb_dec_u8(d); + uint32_t pQueueFamilyPropertyCount_v; + memset(&pQueueFamilyPropertyCount_v, 0, sizeof(pQueueFamilyPropertyCount_v)); + if (has_pQueueFamilyPropertyCount) vkb_dec_bytes(d, &pQueueFamilyPropertyCount_v, sizeof(pQueueFamilyPropertyCount_v)); + uint32_t *pQueueFamilyPropertyCount = has_pQueueFamilyPropertyCount ? &pQueueFamilyPropertyCount_v : NULL; + uint8_t has_pQueueFamilyProperties = vkb_dec_u8(d); uint32_t n_pQueueFamilyProperties = vkb_dec_u32(d); + VkQueueFamilyProperties *pQueueFamilyProperties = has_pQueueFamilyProperties ? (VkQueueFamilyProperties *)vkb_dec_alloc_zero(d, (size_t)n_pQueueFamilyProperties * sizeof(VkQueueFamilyProperties)) : NULL; + if (pQueueFamilyProperties && pQueueFamilyPropertyCount) *pQueueFamilyPropertyCount = n_pQueueFamilyProperties; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceQueueFamilyProperties) { vkb_srv_missing(c, "vkGetPhysicalDeviceQueueFamilyProperties"); return; } + c->dt->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + vkb_enc_u8(e, pQueueFamilyPropertyCount != NULL); + if (pQueueFamilyPropertyCount) vkb_enc_raw(e, pQueueFamilyPropertyCount, sizeof(*pQueueFamilyPropertyCount)); + { + uint32_t rn_ = (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); + uint32_t has_ = pQueueFamilyProperties ? (rn_ < n_pQueueFamilyProperties ? rn_ : n_pQueueFamilyProperties) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &pQueueFamilyProperties[i_], sizeof(VkQueueFamilyProperties)); + } +} + +void vkb_sv_vkGetPhysicalDeviceQueueFamilyProperties2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pQueueFamilyPropertyCount = vkb_dec_u8(d); + uint32_t pQueueFamilyPropertyCount_v; + memset(&pQueueFamilyPropertyCount_v, 0, sizeof(pQueueFamilyPropertyCount_v)); + if (has_pQueueFamilyPropertyCount) vkb_dec_bytes(d, &pQueueFamilyPropertyCount_v, sizeof(pQueueFamilyPropertyCount_v)); + uint32_t *pQueueFamilyPropertyCount = has_pQueueFamilyPropertyCount ? &pQueueFamilyPropertyCount_v : NULL; + uint8_t has_pQueueFamilyProperties = vkb_dec_u8(d); uint32_t n_pQueueFamilyProperties = vkb_dec_u32(d); + VkQueueFamilyProperties2 *pQueueFamilyProperties = has_pQueueFamilyProperties ? (VkQueueFamilyProperties2 *)vkb_dec_alloc_zero(d, (size_t)n_pQueueFamilyProperties * sizeof(VkQueueFamilyProperties2)) : NULL; + for (uint32_t i_ = 0; pQueueFamilyProperties && i_ < n_pQueueFamilyProperties; i_++) vkb_dec_out_template(d, &pQueueFamilyProperties[i_], sizeof(VkQueueFamilyProperties2)); + if (pQueueFamilyProperties && pQueueFamilyPropertyCount) *pQueueFamilyPropertyCount = n_pQueueFamilyProperties; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceQueueFamilyProperties2) { vkb_srv_missing(c, "vkGetPhysicalDeviceQueueFamilyProperties2"); return; } + c->dt->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + vkb_enc_u8(e, pQueueFamilyPropertyCount != NULL); + if (pQueueFamilyPropertyCount) vkb_enc_raw(e, pQueueFamilyPropertyCount, sizeof(*pQueueFamilyPropertyCount)); + { + uint32_t rn_ = (pQueueFamilyPropertyCount ? *pQueueFamilyPropertyCount : 0); + uint32_t has_ = pQueueFamilyProperties ? (rn_ < n_pQueueFamilyProperties ? rn_ : n_pQueueFamilyProperties) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_out_struct(e, &pQueueFamilyProperties[i_], sizeof(VkQueueFamilyProperties2)); + } +} + +void vkb_sv_vkGetPhysicalDeviceSparseImageFormatProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + VkFormat format; + vkb_dec_bytes(d, &format, sizeof(format)); + VkImageType type; + vkb_dec_bytes(d, &type, sizeof(type)); + VkSampleCountFlagBits samples; + vkb_dec_bytes(d, &samples, sizeof(samples)); + VkImageUsageFlags usage; + vkb_dec_bytes(d, &usage, sizeof(usage)); + VkImageTiling tiling; + vkb_dec_bytes(d, &tiling, sizeof(tiling)); + uint8_t has_pPropertyCount = vkb_dec_u8(d); + uint32_t pPropertyCount_v; + memset(&pPropertyCount_v, 0, sizeof(pPropertyCount_v)); + if (has_pPropertyCount) vkb_dec_bytes(d, &pPropertyCount_v, sizeof(pPropertyCount_v)); + uint32_t *pPropertyCount = has_pPropertyCount ? &pPropertyCount_v : NULL; + uint8_t has_pProperties = vkb_dec_u8(d); uint32_t n_pProperties = vkb_dec_u32(d); + VkSparseImageFormatProperties *pProperties = has_pProperties ? (VkSparseImageFormatProperties *)vkb_dec_alloc_zero(d, (size_t)n_pProperties * sizeof(VkSparseImageFormatProperties)) : NULL; + if (pProperties && pPropertyCount) *pPropertyCount = n_pProperties; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceSparseImageFormatProperties) { vkb_srv_missing(c, "vkGetPhysicalDeviceSparseImageFormatProperties"); return; } + c->dt->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); + vkb_enc_u8(e, pPropertyCount != NULL); + if (pPropertyCount) vkb_enc_raw(e, pPropertyCount, sizeof(*pPropertyCount)); + { + uint32_t rn_ = (pPropertyCount ? *pPropertyCount : 0); + uint32_t has_ = pProperties ? (rn_ < n_pProperties ? rn_ : n_pProperties) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_raw(e, &pProperties[i_], sizeof(VkSparseImageFormatProperties)); + } +} + +void vkb_sv_vkGetPhysicalDeviceSparseImageFormatProperties2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPhysicalDeviceSparseImageFormatInfo2 *a_ = (VkPhysicalDeviceSparseImageFormatInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPhysicalDeviceSparseImageFormatInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPhysicalDeviceSparseImageFormatInfo2(d, &a_[i_]); + pFormatInfo = a_; + } else { + pFormatInfo = NULL; + } + uint8_t has_pPropertyCount = vkb_dec_u8(d); + uint32_t pPropertyCount_v; + memset(&pPropertyCount_v, 0, sizeof(pPropertyCount_v)); + if (has_pPropertyCount) vkb_dec_bytes(d, &pPropertyCount_v, sizeof(pPropertyCount_v)); + uint32_t *pPropertyCount = has_pPropertyCount ? &pPropertyCount_v : NULL; + uint8_t has_pProperties = vkb_dec_u8(d); uint32_t n_pProperties = vkb_dec_u32(d); + VkSparseImageFormatProperties2 *pProperties = has_pProperties ? (VkSparseImageFormatProperties2 *)vkb_dec_alloc_zero(d, (size_t)n_pProperties * sizeof(VkSparseImageFormatProperties2)) : NULL; + for (uint32_t i_ = 0; pProperties && i_ < n_pProperties; i_++) vkb_dec_out_template(d, &pProperties[i_], sizeof(VkSparseImageFormatProperties2)); + if (pProperties && pPropertyCount) *pPropertyCount = n_pProperties; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceSparseImageFormatProperties2) { vkb_srv_missing(c, "vkGetPhysicalDeviceSparseImageFormatProperties2"); return; } + c->dt->vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); + vkb_enc_u8(e, pPropertyCount != NULL); + if (pPropertyCount) vkb_enc_raw(e, pPropertyCount, sizeof(*pPropertyCount)); + { + uint32_t rn_ = (pPropertyCount ? *pPropertyCount : 0); + uint32_t has_ = pProperties ? (rn_ < n_pProperties ? rn_ : n_pProperties) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_out_struct(e, &pProperties[i_], sizeof(VkSparseImageFormatProperties2)); + } +} + +void vkb_sv_vkGetPhysicalDeviceToolProperties(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkPhysicalDevice physicalDevice = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + uint8_t has_pToolCount = vkb_dec_u8(d); + uint32_t pToolCount_v; + memset(&pToolCount_v, 0, sizeof(pToolCount_v)); + if (has_pToolCount) vkb_dec_bytes(d, &pToolCount_v, sizeof(pToolCount_v)); + uint32_t *pToolCount = has_pToolCount ? &pToolCount_v : NULL; + uint8_t has_pToolProperties = vkb_dec_u8(d); uint32_t n_pToolProperties = vkb_dec_u32(d); + VkPhysicalDeviceToolProperties *pToolProperties = has_pToolProperties ? (VkPhysicalDeviceToolProperties *)vkb_dec_alloc_zero(d, (size_t)n_pToolProperties * sizeof(VkPhysicalDeviceToolProperties)) : NULL; + for (uint32_t i_ = 0; pToolProperties && i_ < n_pToolProperties; i_++) vkb_dec_out_template(d, &pToolProperties[i_], sizeof(VkPhysicalDeviceToolProperties)); + if (pToolProperties && pToolCount) *pToolCount = n_pToolProperties; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPhysicalDeviceToolProperties) { vkb_srv_missing(c, "vkGetPhysicalDeviceToolProperties"); return; } + VkResult r_ = c->dt->vkGetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pToolCount != NULL); + if (pToolCount) vkb_enc_raw(e, pToolCount, sizeof(*pToolCount)); + { + uint32_t rn_ = (pToolCount ? *pToolCount : 0); + uint32_t has_ = pToolProperties ? (rn_ < n_pToolProperties ? rn_ : n_pToolProperties) : 0; + vkb_enc_u32(e, rn_); vkb_enc_u32(e, has_); + for (uint32_t i_ = 0; i_ < has_; i_++) vkb_enc_out_struct(e, &pToolProperties[i_], sizeof(VkPhysicalDeviceToolProperties)); + } +} + +void vkb_sv_vkGetPipelineCacheData(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkPipelineCache pipelineCache; + vkb_dec_bytes(d, &pipelineCache, sizeof(pipelineCache)); + uint8_t has_pDataSize = vkb_dec_u8(d); + size_t pDataSize_v; + memset(&pDataSize_v, 0, sizeof(pDataSize_v)); + if (has_pDataSize) vkb_dec_bytes(d, &pDataSize_v, sizeof(pDataSize_v)); + size_t *pDataSize = has_pDataSize ? &pDataSize_v : NULL; + uint8_t has_pData = vkb_dec_u8(d); uint64_t n_pData = vkb_dec_u64(d); + void *pData = has_pData ? vkb_dec_alloc(d, (size_t)n_pData) : NULL; + if (pDataSize && pData) *pDataSize = (size_t)n_pData; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetPipelineCacheData) { vkb_srv_missing(c, "vkGetPipelineCacheData"); return; } + VkResult r_ = c->dt->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pDataSize != NULL); + if (pDataSize) vkb_enc_raw(e, pDataSize, sizeof(*pDataSize)); + vkb_enc_u64(e, pDataSize ? (uint64_t)*pDataSize : 0); vkb_enc_blob(e, pData, pData && pDataSize ? (size_t)*pDataSize : 0); +} + +void vkb_sv_vkGetQueryPoolResults(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkQueryPool queryPool; + vkb_dec_bytes(d, &queryPool, sizeof(queryPool)); + uint32_t firstQuery; + vkb_dec_bytes(d, &firstQuery, sizeof(firstQuery)); + uint32_t queryCount; + vkb_dec_bytes(d, &queryCount, sizeof(queryCount)); + size_t dataSize; + vkb_dec_bytes(d, &dataSize, sizeof(dataSize)); + uint8_t has_pData = vkb_dec_u8(d); uint64_t n_pData = vkb_dec_u64(d); + void *pData = has_pData ? vkb_dec_alloc(d, (size_t)n_pData) : NULL; + VkDeviceSize stride; + vkb_dec_bytes(d, &stride, sizeof(stride)); + VkQueryResultFlags flags; + vkb_dec_bytes(d, &flags, sizeof(flags)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetQueryPoolResults) { vkb_srv_missing(c, "vkGetQueryPoolResults"); return; } + VkResult r_ = c->dt->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_blob(e, pData, (size_t)n_pData); +} + +void vkb_sv_vkGetRenderAreaGranularity(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkRenderPass renderPass; + vkb_dec_bytes(d, &renderPass, sizeof(renderPass)); + uint8_t has_pGranularity = vkb_dec_u8(d); + VkExtent2D pGranularity_v; + memset(&pGranularity_v, 0, sizeof(pGranularity_v)); + VkExtent2D *pGranularity = has_pGranularity ? &pGranularity_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetRenderAreaGranularity) { vkb_srv_missing(c, "vkGetRenderAreaGranularity"); return; } + c->dt->vkGetRenderAreaGranularity(device, renderPass, pGranularity); + vkb_enc_u8(e, pGranularity != NULL); + if (pGranularity) vkb_enc_raw(e, pGranularity, sizeof(*pGranularity)); +} + +void vkb_sv_vkGetSemaphoreCounterValue(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkSemaphore semaphore; + vkb_dec_bytes(d, &semaphore, sizeof(semaphore)); + uint8_t has_pValue = vkb_dec_u8(d); + uint64_t pValue_v; + memset(&pValue_v, 0, sizeof(pValue_v)); + if (has_pValue) vkb_dec_bytes(d, &pValue_v, sizeof(pValue_v)); + uint64_t *pValue = has_pValue ? &pValue_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetSemaphoreCounterValue) { vkb_srv_missing(c, "vkGetSemaphoreCounterValue"); return; } + VkResult r_ = c->dt->vkGetSemaphoreCounterValue(device, semaphore, pValue); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_u8(e, pValue != NULL); + if (pValue) vkb_enc_raw(e, pValue, sizeof(*pValue)); +} + +void vkb_sv_vkGetSemaphoreFdKHR(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkSemaphoreGetFdInfoKHR *pGetFdInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSemaphoreGetFdInfoKHR *a_ = (VkSemaphoreGetFdInfoKHR *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSemaphoreGetFdInfoKHR)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSemaphoreGetFdInfoKHR(d, &a_[i_]); + pGetFdInfo = a_; + } else { + pGetFdInfo = NULL; + } + int pFd_v = -1; int *pFd = vkb_dec_u8(d) ? &pFd_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetSemaphoreFdKHR) { vkb_srv_missing(c, "vkGetSemaphoreFdKHR"); return; } + VkResult r_ = c->dt->vkGetSemaphoreFdKHR(device, pGetFdInfo, pFd); + vkb_enc_bytes(e, &r_, sizeof(r_)); + vkb_enc_fd(e, pFd ? *pFd : -1); + if (pFd && *pFd >= 0) vkb_srv_close_after_send(c, *pFd); +} + +void vkb_sv_vkGetShaderModuleCreateInfoIdentifierEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkShaderModuleCreateInfo *pCreateInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkShaderModuleCreateInfo *a_ = (VkShaderModuleCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkShaderModuleCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkShaderModuleCreateInfo(d, &a_[i_]); + pCreateInfo = a_; + } else { + pCreateInfo = NULL; + } + uint8_t has_pIdentifier = vkb_dec_u8(d); + VkShaderModuleIdentifierEXT pIdentifier_v; + memset(&pIdentifier_v, 0, sizeof(pIdentifier_v)); + if (has_pIdentifier) vkb_dec_out_template(d, &pIdentifier_v, sizeof(VkShaderModuleIdentifierEXT)); + VkShaderModuleIdentifierEXT *pIdentifier = has_pIdentifier ? &pIdentifier_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetShaderModuleCreateInfoIdentifierEXT) { vkb_srv_missing(c, "vkGetShaderModuleCreateInfoIdentifierEXT"); return; } + c->dt->vkGetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier); + vkb_enc_u8(e, pIdentifier != NULL); + if (pIdentifier) vkb_enc_out_struct(e, pIdentifier, sizeof(VkShaderModuleIdentifierEXT)); +} + +void vkb_sv_vkGetShaderModuleIdentifierEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkShaderModule shaderModule; + vkb_dec_bytes(d, &shaderModule, sizeof(shaderModule)); + uint8_t has_pIdentifier = vkb_dec_u8(d); + VkShaderModuleIdentifierEXT pIdentifier_v; + memset(&pIdentifier_v, 0, sizeof(pIdentifier_v)); + if (has_pIdentifier) vkb_dec_out_template(d, &pIdentifier_v, sizeof(VkShaderModuleIdentifierEXT)); + VkShaderModuleIdentifierEXT *pIdentifier = has_pIdentifier ? &pIdentifier_v : NULL; + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkGetShaderModuleIdentifierEXT) { vkb_srv_missing(c, "vkGetShaderModuleIdentifierEXT"); return; } + c->dt->vkGetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier); + vkb_enc_u8(e, pIdentifier != NULL); + if (pIdentifier) vkb_enc_out_struct(e, pIdentifier, sizeof(VkShaderModuleIdentifierEXT)); +} + +void vkb_sv_vkImportFenceFdKHR(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkImportFenceFdInfoKHR *pImportFenceFdInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImportFenceFdInfoKHR *a_ = (VkImportFenceFdInfoKHR *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImportFenceFdInfoKHR)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImportFenceFdInfoKHR(d, &a_[i_]); + pImportFenceFdInfo = a_; + } else { + pImportFenceFdInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkImportFenceFdKHR) { vkb_srv_missing(c, "vkImportFenceFdKHR"); return; } + VkResult r_ = c->dt->vkImportFenceFdKHR(device, pImportFenceFdInfo); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkImportSemaphoreFdKHR(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImportSemaphoreFdInfoKHR *a_ = (VkImportSemaphoreFdInfoKHR *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImportSemaphoreFdInfoKHR)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImportSemaphoreFdInfoKHR(d, &a_[i_]); + pImportSemaphoreFdInfo = a_; + } else { + pImportSemaphoreFdInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkImportSemaphoreFdKHR) { vkb_srv_missing(c, "vkImportSemaphoreFdKHR"); return; } + VkResult r_ = c->dt->vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkMergePipelineCaches(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkPipelineCache dstCache; + vkb_dec_bytes(d, &dstCache, sizeof(dstCache)); + uint32_t srcCacheCount; + vkb_dec_bytes(d, &srcCacheCount, sizeof(srcCacheCount)); + const VkPipelineCache *pSrcCaches; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pSrcCaches = (const VkPipelineCache *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkPipelineCache)); + } else { + pSrcCaches = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkMergePipelineCaches) { vkb_srv_missing(c, "vkMergePipelineCaches"); return; } + VkResult r_ = c->dt->vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkQueueBindSparse(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkQueue queue = (VkQueue)(uintptr_t)vkb_dec_u64(d); + uint32_t bindInfoCount; + vkb_dec_bytes(d, &bindInfoCount, sizeof(bindInfoCount)); + const VkBindSparseInfo *pBindInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBindSparseInfo *a_ = (VkBindSparseInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBindSparseInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBindSparseInfo(d, &a_[i_]); + pBindInfo = a_; + } else { + pBindInfo = NULL; + } + VkFence fence; + vkb_dec_bytes(d, &fence, sizeof(fence)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkQueueBindSparse) { vkb_srv_missing(c, "vkQueueBindSparse"); return; } + VkResult r_ = c->dt->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkQueueSubmit(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkQueue queue = (VkQueue)(uintptr_t)vkb_dec_u64(d); + uint32_t submitCount; + vkb_dec_bytes(d, &submitCount, sizeof(submitCount)); + const VkSubmitInfo *pSubmits; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSubmitInfo *a_ = (VkSubmitInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSubmitInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSubmitInfo(d, &a_[i_]); + pSubmits = a_; + } else { + pSubmits = NULL; + } + VkFence fence; + vkb_dec_bytes(d, &fence, sizeof(fence)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkQueueSubmit) { vkb_srv_missing(c, "vkQueueSubmit"); return; } + VkResult r_ = c->dt->vkQueueSubmit(queue, submitCount, pSubmits, fence); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkQueueSubmit2(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkQueue queue = (VkQueue)(uintptr_t)vkb_dec_u64(d); + uint32_t submitCount; + vkb_dec_bytes(d, &submitCount, sizeof(submitCount)); + const VkSubmitInfo2 *pSubmits; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSubmitInfo2 *a_ = (VkSubmitInfo2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSubmitInfo2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSubmitInfo2(d, &a_[i_]); + pSubmits = a_; + } else { + pSubmits = NULL; + } + VkFence fence; + vkb_dec_bytes(d, &fence, sizeof(fence)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkQueueSubmit2) { vkb_srv_missing(c, "vkQueueSubmit2"); return; } + VkResult r_ = c->dt->vkQueueSubmit2(queue, submitCount, pSubmits, fence); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkQueueWaitIdle(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkQueue queue = (VkQueue)(uintptr_t)vkb_dec_u64(d); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkQueueWaitIdle) { vkb_srv_missing(c, "vkQueueWaitIdle"); return; } + VkResult r_ = c->dt->vkQueueWaitIdle(queue); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkResetCommandBuffer(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkCommandBuffer commandBuffer = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + VkCommandBufferResetFlags flags; + vkb_dec_bytes(d, &flags, sizeof(flags)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkResetCommandBuffer) { vkb_srv_missing(c, "vkResetCommandBuffer"); return; } + VkResult r_ = c->dt->vkResetCommandBuffer(commandBuffer, flags); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkResetCommandPool(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkCommandPool commandPool; + vkb_dec_bytes(d, &commandPool, sizeof(commandPool)); + VkCommandPoolResetFlags flags; + vkb_dec_bytes(d, &flags, sizeof(flags)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkResetCommandPool) { vkb_srv_missing(c, "vkResetCommandPool"); return; } + VkResult r_ = c->dt->vkResetCommandPool(device, commandPool, flags); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkResetDescriptorPool(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkDescriptorPool descriptorPool; + vkb_dec_bytes(d, &descriptorPool, sizeof(descriptorPool)); + VkDescriptorPoolResetFlags flags; + vkb_dec_bytes(d, &flags, sizeof(flags)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkResetDescriptorPool) { vkb_srv_missing(c, "vkResetDescriptorPool"); return; } + VkResult r_ = c->dt->vkResetDescriptorPool(device, descriptorPool, flags); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkResetEvent(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkEvent event; + vkb_dec_bytes(d, &event, sizeof(event)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkResetEvent) { vkb_srv_missing(c, "vkResetEvent"); return; } + VkResult r_ = c->dt->vkResetEvent(device, event); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkResetFences(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + uint32_t fenceCount; + vkb_dec_bytes(d, &fenceCount, sizeof(fenceCount)); + const VkFence *pFences; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pFences = (const VkFence *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkFence)); + } else { + pFences = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkResetFences) { vkb_srv_missing(c, "vkResetFences"); return; } + VkResult r_ = c->dt->vkResetFences(device, fenceCount, pFences); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkResetQueryPool(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkQueryPool queryPool; + vkb_dec_bytes(d, &queryPool, sizeof(queryPool)); + uint32_t firstQuery; + vkb_dec_bytes(d, &firstQuery, sizeof(firstQuery)); + uint32_t queryCount; + vkb_dec_bytes(d, &queryCount, sizeof(queryCount)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkResetQueryPool) { vkb_srv_missing(c, "vkResetQueryPool"); return; } + c->dt->vkResetQueryPool(device, queryPool, firstQuery, queryCount); +} + +void vkb_sv_vkSetDeviceMemoryPriorityEXT(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkDeviceMemory memory; + vkb_dec_bytes(d, &memory, sizeof(memory)); + float priority; + vkb_dec_bytes(d, &priority, sizeof(priority)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkSetDeviceMemoryPriorityEXT) { vkb_srv_missing(c, "vkSetDeviceMemoryPriorityEXT"); return; } + c->dt->vkSetDeviceMemoryPriorityEXT(device, memory, priority); +} + +void vkb_sv_vkSetEvent(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkEvent event; + vkb_dec_bytes(d, &event, sizeof(event)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkSetEvent) { vkb_srv_missing(c, "vkSetEvent"); return; } + VkResult r_ = c->dt->vkSetEvent(device, event); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkSignalSemaphore(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkSemaphoreSignalInfo *pSignalInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSemaphoreSignalInfo *a_ = (VkSemaphoreSignalInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSemaphoreSignalInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSemaphoreSignalInfo(d, &a_[i_]); + pSignalInfo = a_; + } else { + pSignalInfo = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkSignalSemaphore) { vkb_srv_missing(c, "vkSignalSemaphore"); return; } + VkResult r_ = c->dt->vkSignalSemaphore(device, pSignalInfo); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkTrimCommandPool(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + VkCommandPool commandPool; + vkb_dec_bytes(d, &commandPool, sizeof(commandPool)); + VkCommandPoolTrimFlags flags; + vkb_dec_bytes(d, &flags, sizeof(flags)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkTrimCommandPool) { vkb_srv_missing(c, "vkTrimCommandPool"); return; } + c->dt->vkTrimCommandPool(device, commandPool, flags); +} + +void vkb_sv_vkUpdateDescriptorSets(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + uint32_t descriptorWriteCount; + vkb_dec_bytes(d, &descriptorWriteCount, sizeof(descriptorWriteCount)); + const VkWriteDescriptorSet *pDescriptorWrites; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkWriteDescriptorSet *a_ = (VkWriteDescriptorSet *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkWriteDescriptorSet)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkWriteDescriptorSet(d, &a_[i_]); + pDescriptorWrites = a_; + } else { + pDescriptorWrites = NULL; + } + uint32_t descriptorCopyCount; + vkb_dec_bytes(d, &descriptorCopyCount, sizeof(descriptorCopyCount)); + const VkCopyDescriptorSet *pDescriptorCopies; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCopyDescriptorSet *a_ = (VkCopyDescriptorSet *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCopyDescriptorSet)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkCopyDescriptorSet(d, &a_[i_]); + pDescriptorCopies = a_; + } else { + pDescriptorCopies = NULL; + } + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkUpdateDescriptorSets) { vkb_srv_missing(c, "vkUpdateDescriptorSets"); return; } + c->dt->vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); +} + +void vkb_sv_vkWaitForFences(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + uint32_t fenceCount; + vkb_dec_bytes(d, &fenceCount, sizeof(fenceCount)); + const VkFence *pFences; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + pFences = (const VkFence *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkFence)); + } else { + pFences = NULL; + } + VkBool32 waitAll; + vkb_dec_bytes(d, &waitAll, sizeof(waitAll)); + uint64_t timeout; + vkb_dec_bytes(d, &timeout, sizeof(timeout)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkWaitForFences) { vkb_srv_missing(c, "vkWaitForFences"); return; } + VkResult r_ = c->dt->vkWaitForFences(device, fenceCount, pFences, waitAll, timeout); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +void vkb_sv_vkWaitSemaphores(vkb_srv_call *c) +{ + vkb_dec *d = &c->d; + vkb_enc *e = &c->r; + (void)e; + VkDevice device = (VkDevice)(uintptr_t)vkb_dec_u64(d); + const VkSemaphoreWaitInfo *pWaitInfo; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSemaphoreWaitInfo *a_ = (VkSemaphoreWaitInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSemaphoreWaitInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSemaphoreWaitInfo(d, &a_[i_]); + pWaitInfo = a_; + } else { + pWaitInfo = NULL; + } + uint64_t timeout; + vkb_dec_bytes(d, &timeout, sizeof(timeout)); + if (d->err) { vkb_srv_bad_message(c); return; } + if (!c->dt->vkWaitSemaphores) { vkb_srv_missing(c, "vkWaitSemaphores"); return; } + VkResult r_ = c->dt->vkWaitSemaphores(device, pWaitInfo, timeout); + vkb_enc_bytes(e, &r_, sizeof(r_)); +} + +const vkb_srv_handler vkb_srv_handlers[VKB_CMD_COUNT] = { + [VKB_CMD_vkbHello] = vkb_sv_vkbHello, + [VKB_CMD_vkbQueryServer] = vkb_sv_vkbQueryServer, + [VKB_CMD_vkbDescUpdateRaw] = vkb_sv_vkbDescUpdateRaw, + [VKB_CMD_vkbPushDescRaw] = vkb_sv_vkbPushDescRaw, + [VKB_CMD_vkAllocateCommandBuffers] = vkb_sv_vkAllocateCommandBuffers, + [VKB_CMD_vkAllocateDescriptorSets] = vkb_sv_vkAllocateDescriptorSets, + [VKB_CMD_vkAllocateMemory] = vkb_sv_vkAllocateMemory, + [VKB_CMD_vkBeginCommandBuffer] = vkb_sv_vkBeginCommandBuffer, + [VKB_CMD_vkBindBufferMemory] = vkb_sv_vkBindBufferMemory, + [VKB_CMD_vkBindBufferMemory2] = vkb_sv_vkBindBufferMemory2, + [VKB_CMD_vkBindImageMemory] = vkb_sv_vkBindImageMemory, + [VKB_CMD_vkBindImageMemory2] = vkb_sv_vkBindImageMemory2, + [VKB_CMD_vkCmdBeginConditionalRenderingEXT] = vkb_sv_vkCmdBeginConditionalRenderingEXT, + [VKB_CMD_vkCmdBeginQuery] = vkb_sv_vkCmdBeginQuery, + [VKB_CMD_vkCmdBeginQueryIndexedEXT] = vkb_sv_vkCmdBeginQueryIndexedEXT, + [VKB_CMD_vkCmdBeginRenderPass] = vkb_sv_vkCmdBeginRenderPass, + [VKB_CMD_vkCmdBeginRenderPass2] = vkb_sv_vkCmdBeginRenderPass2, + [VKB_CMD_vkCmdBeginRendering] = vkb_sv_vkCmdBeginRendering, + [VKB_CMD_vkCmdBeginTransformFeedbackEXT] = vkb_sv_vkCmdBeginTransformFeedbackEXT, + [VKB_CMD_vkCmdBindDescriptorSets] = vkb_sv_vkCmdBindDescriptorSets, + [VKB_CMD_vkCmdBindIndexBuffer] = vkb_sv_vkCmdBindIndexBuffer, + [VKB_CMD_vkCmdBindPipeline] = vkb_sv_vkCmdBindPipeline, + [VKB_CMD_vkCmdBindTransformFeedbackBuffersEXT] = vkb_sv_vkCmdBindTransformFeedbackBuffersEXT, + [VKB_CMD_vkCmdBindVertexBuffers] = vkb_sv_vkCmdBindVertexBuffers, + [VKB_CMD_vkCmdBindVertexBuffers2] = vkb_sv_vkCmdBindVertexBuffers2, + [VKB_CMD_vkCmdBlitImage] = vkb_sv_vkCmdBlitImage, + [VKB_CMD_vkCmdBlitImage2] = vkb_sv_vkCmdBlitImage2, + [VKB_CMD_vkCmdClearAttachments] = vkb_sv_vkCmdClearAttachments, + [VKB_CMD_vkCmdClearColorImage] = vkb_sv_vkCmdClearColorImage, + [VKB_CMD_vkCmdClearDepthStencilImage] = vkb_sv_vkCmdClearDepthStencilImage, + [VKB_CMD_vkCmdCopyBuffer] = vkb_sv_vkCmdCopyBuffer, + [VKB_CMD_vkCmdCopyBuffer2] = vkb_sv_vkCmdCopyBuffer2, + [VKB_CMD_vkCmdCopyBufferToImage] = vkb_sv_vkCmdCopyBufferToImage, + [VKB_CMD_vkCmdCopyBufferToImage2] = vkb_sv_vkCmdCopyBufferToImage2, + [VKB_CMD_vkCmdCopyImage] = vkb_sv_vkCmdCopyImage, + [VKB_CMD_vkCmdCopyImage2] = vkb_sv_vkCmdCopyImage2, + [VKB_CMD_vkCmdCopyImageToBuffer] = vkb_sv_vkCmdCopyImageToBuffer, + [VKB_CMD_vkCmdCopyImageToBuffer2] = vkb_sv_vkCmdCopyImageToBuffer2, + [VKB_CMD_vkCmdCopyQueryPoolResults] = vkb_sv_vkCmdCopyQueryPoolResults, + [VKB_CMD_vkCmdDispatch] = vkb_sv_vkCmdDispatch, + [VKB_CMD_vkCmdDispatchBase] = vkb_sv_vkCmdDispatchBase, + [VKB_CMD_vkCmdDispatchIndirect] = vkb_sv_vkCmdDispatchIndirect, + [VKB_CMD_vkCmdDraw] = vkb_sv_vkCmdDraw, + [VKB_CMD_vkCmdDrawIndexed] = vkb_sv_vkCmdDrawIndexed, + [VKB_CMD_vkCmdDrawIndexedIndirect] = vkb_sv_vkCmdDrawIndexedIndirect, + [VKB_CMD_vkCmdDrawIndexedIndirectCount] = vkb_sv_vkCmdDrawIndexedIndirectCount, + [VKB_CMD_vkCmdDrawIndirect] = vkb_sv_vkCmdDrawIndirect, + [VKB_CMD_vkCmdDrawIndirectByteCountEXT] = vkb_sv_vkCmdDrawIndirectByteCountEXT, + [VKB_CMD_vkCmdDrawIndirectCount] = vkb_sv_vkCmdDrawIndirectCount, + [VKB_CMD_vkCmdDrawMultiEXT] = vkb_sv_vkCmdDrawMultiEXT, + [VKB_CMD_vkCmdDrawMultiIndexedEXT] = vkb_sv_vkCmdDrawMultiIndexedEXT, + [VKB_CMD_vkCmdEndConditionalRenderingEXT] = vkb_sv_vkCmdEndConditionalRenderingEXT, + [VKB_CMD_vkCmdEndQuery] = vkb_sv_vkCmdEndQuery, + [VKB_CMD_vkCmdEndQueryIndexedEXT] = vkb_sv_vkCmdEndQueryIndexedEXT, + [VKB_CMD_vkCmdEndRenderPass] = vkb_sv_vkCmdEndRenderPass, + [VKB_CMD_vkCmdEndRenderPass2] = vkb_sv_vkCmdEndRenderPass2, + [VKB_CMD_vkCmdEndRendering] = vkb_sv_vkCmdEndRendering, + [VKB_CMD_vkCmdEndTransformFeedbackEXT] = vkb_sv_vkCmdEndTransformFeedbackEXT, + [VKB_CMD_vkCmdExecuteCommands] = vkb_sv_vkCmdExecuteCommands, + [VKB_CMD_vkCmdFillBuffer] = vkb_sv_vkCmdFillBuffer, + [VKB_CMD_vkCmdNextSubpass] = vkb_sv_vkCmdNextSubpass, + [VKB_CMD_vkCmdNextSubpass2] = vkb_sv_vkCmdNextSubpass2, + [VKB_CMD_vkCmdPipelineBarrier] = vkb_sv_vkCmdPipelineBarrier, + [VKB_CMD_vkCmdPipelineBarrier2] = vkb_sv_vkCmdPipelineBarrier2, + [VKB_CMD_vkCmdPushConstants] = vkb_sv_vkCmdPushConstants, + [VKB_CMD_vkCmdPushDescriptorSetKHR] = vkb_sv_vkCmdPushDescriptorSetKHR, + [VKB_CMD_vkCmdResetEvent] = vkb_sv_vkCmdResetEvent, + [VKB_CMD_vkCmdResetEvent2] = vkb_sv_vkCmdResetEvent2, + [VKB_CMD_vkCmdResetQueryPool] = vkb_sv_vkCmdResetQueryPool, + [VKB_CMD_vkCmdResolveImage] = vkb_sv_vkCmdResolveImage, + [VKB_CMD_vkCmdResolveImage2] = vkb_sv_vkCmdResolveImage2, + [VKB_CMD_vkCmdSetAlphaToCoverageEnableEXT] = vkb_sv_vkCmdSetAlphaToCoverageEnableEXT, + [VKB_CMD_vkCmdSetAlphaToOneEnableEXT] = vkb_sv_vkCmdSetAlphaToOneEnableEXT, + [VKB_CMD_vkCmdSetBlendConstants] = vkb_sv_vkCmdSetBlendConstants, + [VKB_CMD_vkCmdSetColorBlendAdvancedEXT] = vkb_sv_vkCmdSetColorBlendAdvancedEXT, + [VKB_CMD_vkCmdSetColorBlendEnableEXT] = vkb_sv_vkCmdSetColorBlendEnableEXT, + [VKB_CMD_vkCmdSetColorBlendEquationEXT] = vkb_sv_vkCmdSetColorBlendEquationEXT, + [VKB_CMD_vkCmdSetColorWriteEnableEXT] = vkb_sv_vkCmdSetColorWriteEnableEXT, + [VKB_CMD_vkCmdSetColorWriteMaskEXT] = vkb_sv_vkCmdSetColorWriteMaskEXT, + [VKB_CMD_vkCmdSetConservativeRasterizationModeEXT] = vkb_sv_vkCmdSetConservativeRasterizationModeEXT, + [VKB_CMD_vkCmdSetCoverageModulationModeNV] = vkb_sv_vkCmdSetCoverageModulationModeNV, + [VKB_CMD_vkCmdSetCoverageModulationTableEnableNV] = vkb_sv_vkCmdSetCoverageModulationTableEnableNV, + [VKB_CMD_vkCmdSetCoverageModulationTableNV] = vkb_sv_vkCmdSetCoverageModulationTableNV, + [VKB_CMD_vkCmdSetCoverageReductionModeNV] = vkb_sv_vkCmdSetCoverageReductionModeNV, + [VKB_CMD_vkCmdSetCoverageToColorEnableNV] = vkb_sv_vkCmdSetCoverageToColorEnableNV, + [VKB_CMD_vkCmdSetCoverageToColorLocationNV] = vkb_sv_vkCmdSetCoverageToColorLocationNV, + [VKB_CMD_vkCmdSetCullMode] = vkb_sv_vkCmdSetCullMode, + [VKB_CMD_vkCmdSetDepthBias] = vkb_sv_vkCmdSetDepthBias, + [VKB_CMD_vkCmdSetDepthBiasEnable] = vkb_sv_vkCmdSetDepthBiasEnable, + [VKB_CMD_vkCmdSetDepthBounds] = vkb_sv_vkCmdSetDepthBounds, + [VKB_CMD_vkCmdSetDepthBoundsTestEnable] = vkb_sv_vkCmdSetDepthBoundsTestEnable, + [VKB_CMD_vkCmdSetDepthClampEnableEXT] = vkb_sv_vkCmdSetDepthClampEnableEXT, + [VKB_CMD_vkCmdSetDepthClipEnableEXT] = vkb_sv_vkCmdSetDepthClipEnableEXT, + [VKB_CMD_vkCmdSetDepthClipNegativeOneToOneEXT] = vkb_sv_vkCmdSetDepthClipNegativeOneToOneEXT, + [VKB_CMD_vkCmdSetDepthCompareOp] = vkb_sv_vkCmdSetDepthCompareOp, + [VKB_CMD_vkCmdSetDepthTestEnable] = vkb_sv_vkCmdSetDepthTestEnable, + [VKB_CMD_vkCmdSetDepthWriteEnable] = vkb_sv_vkCmdSetDepthWriteEnable, + [VKB_CMD_vkCmdSetDeviceMask] = vkb_sv_vkCmdSetDeviceMask, + [VKB_CMD_vkCmdSetDiscardRectangleEXT] = vkb_sv_vkCmdSetDiscardRectangleEXT, + [VKB_CMD_vkCmdSetDiscardRectangleEnableEXT] = vkb_sv_vkCmdSetDiscardRectangleEnableEXT, + [VKB_CMD_vkCmdSetDiscardRectangleModeEXT] = vkb_sv_vkCmdSetDiscardRectangleModeEXT, + [VKB_CMD_vkCmdSetEvent] = vkb_sv_vkCmdSetEvent, + [VKB_CMD_vkCmdSetEvent2] = vkb_sv_vkCmdSetEvent2, + [VKB_CMD_vkCmdSetExtraPrimitiveOverestimationSizeEXT] = vkb_sv_vkCmdSetExtraPrimitiveOverestimationSizeEXT, + [VKB_CMD_vkCmdSetFragmentShadingRateKHR] = vkb_sv_vkCmdSetFragmentShadingRateKHR, + [VKB_CMD_vkCmdSetFrontFace] = vkb_sv_vkCmdSetFrontFace, + [VKB_CMD_vkCmdSetLineRasterizationModeEXT] = vkb_sv_vkCmdSetLineRasterizationModeEXT, + [VKB_CMD_vkCmdSetLineStippleEXT] = vkb_sv_vkCmdSetLineStippleEXT, + [VKB_CMD_vkCmdSetLineStippleEnableEXT] = vkb_sv_vkCmdSetLineStippleEnableEXT, + [VKB_CMD_vkCmdSetLineWidth] = vkb_sv_vkCmdSetLineWidth, + [VKB_CMD_vkCmdSetLogicOpEXT] = vkb_sv_vkCmdSetLogicOpEXT, + [VKB_CMD_vkCmdSetLogicOpEnableEXT] = vkb_sv_vkCmdSetLogicOpEnableEXT, + [VKB_CMD_vkCmdSetPatchControlPointsEXT] = vkb_sv_vkCmdSetPatchControlPointsEXT, + [VKB_CMD_vkCmdSetPolygonModeEXT] = vkb_sv_vkCmdSetPolygonModeEXT, + [VKB_CMD_vkCmdSetPrimitiveRestartEnable] = vkb_sv_vkCmdSetPrimitiveRestartEnable, + [VKB_CMD_vkCmdSetPrimitiveTopology] = vkb_sv_vkCmdSetPrimitiveTopology, + [VKB_CMD_vkCmdSetProvokingVertexModeEXT] = vkb_sv_vkCmdSetProvokingVertexModeEXT, + [VKB_CMD_vkCmdSetRasterizationSamplesEXT] = vkb_sv_vkCmdSetRasterizationSamplesEXT, + [VKB_CMD_vkCmdSetRasterizationStreamEXT] = vkb_sv_vkCmdSetRasterizationStreamEXT, + [VKB_CMD_vkCmdSetRasterizerDiscardEnable] = vkb_sv_vkCmdSetRasterizerDiscardEnable, + [VKB_CMD_vkCmdSetRepresentativeFragmentTestEnableNV] = vkb_sv_vkCmdSetRepresentativeFragmentTestEnableNV, + [VKB_CMD_vkCmdSetSampleLocationsEXT] = vkb_sv_vkCmdSetSampleLocationsEXT, + [VKB_CMD_vkCmdSetSampleLocationsEnableEXT] = vkb_sv_vkCmdSetSampleLocationsEnableEXT, + [VKB_CMD_vkCmdSetSampleMaskEXT] = vkb_sv_vkCmdSetSampleMaskEXT, + [VKB_CMD_vkCmdSetScissor] = vkb_sv_vkCmdSetScissor, + [VKB_CMD_vkCmdSetScissorWithCount] = vkb_sv_vkCmdSetScissorWithCount, + [VKB_CMD_vkCmdSetShadingRateImageEnableNV] = vkb_sv_vkCmdSetShadingRateImageEnableNV, + [VKB_CMD_vkCmdSetStencilCompareMask] = vkb_sv_vkCmdSetStencilCompareMask, + [VKB_CMD_vkCmdSetStencilOp] = vkb_sv_vkCmdSetStencilOp, + [VKB_CMD_vkCmdSetStencilReference] = vkb_sv_vkCmdSetStencilReference, + [VKB_CMD_vkCmdSetStencilTestEnable] = vkb_sv_vkCmdSetStencilTestEnable, + [VKB_CMD_vkCmdSetStencilWriteMask] = vkb_sv_vkCmdSetStencilWriteMask, + [VKB_CMD_vkCmdSetTessellationDomainOriginEXT] = vkb_sv_vkCmdSetTessellationDomainOriginEXT, + [VKB_CMD_vkCmdSetVertexInputEXT] = vkb_sv_vkCmdSetVertexInputEXT, + [VKB_CMD_vkCmdSetViewport] = vkb_sv_vkCmdSetViewport, + [VKB_CMD_vkCmdSetViewportSwizzleNV] = vkb_sv_vkCmdSetViewportSwizzleNV, + [VKB_CMD_vkCmdSetViewportWScalingEnableNV] = vkb_sv_vkCmdSetViewportWScalingEnableNV, + [VKB_CMD_vkCmdSetViewportWithCount] = vkb_sv_vkCmdSetViewportWithCount, + [VKB_CMD_vkCmdUpdateBuffer] = vkb_sv_vkCmdUpdateBuffer, + [VKB_CMD_vkCmdWaitEvents] = vkb_sv_vkCmdWaitEvents, + [VKB_CMD_vkCmdWaitEvents2] = vkb_sv_vkCmdWaitEvents2, + [VKB_CMD_vkCmdWriteTimestamp] = vkb_sv_vkCmdWriteTimestamp, + [VKB_CMD_vkCmdWriteTimestamp2] = vkb_sv_vkCmdWriteTimestamp2, + [VKB_CMD_vkCreateBuffer] = vkb_sv_vkCreateBuffer, + [VKB_CMD_vkCreateBufferView] = vkb_sv_vkCreateBufferView, + [VKB_CMD_vkCreateCommandPool] = vkb_sv_vkCreateCommandPool, + [VKB_CMD_vkCreateComputePipelines] = vkb_sv_vkCreateComputePipelines, + [VKB_CMD_vkCreateDescriptorPool] = vkb_sv_vkCreateDescriptorPool, + [VKB_CMD_vkCreateDescriptorSetLayout] = vkb_sv_vkCreateDescriptorSetLayout, + [VKB_CMD_vkCreateDescriptorUpdateTemplate] = vkb_sv_vkCreateDescriptorUpdateTemplate, + [VKB_CMD_vkCreateDevice] = vkb_sv_vkCreateDevice, + [VKB_CMD_vkCreateEvent] = vkb_sv_vkCreateEvent, + [VKB_CMD_vkCreateFence] = vkb_sv_vkCreateFence, + [VKB_CMD_vkCreateFramebuffer] = vkb_sv_vkCreateFramebuffer, + [VKB_CMD_vkCreateGraphicsPipelines] = vkb_sv_vkCreateGraphicsPipelines, + [VKB_CMD_vkCreateImage] = vkb_sv_vkCreateImage, + [VKB_CMD_vkCreateImageView] = vkb_sv_vkCreateImageView, + [VKB_CMD_vkCreateInstance] = vkb_sv_vkCreateInstance, + [VKB_CMD_vkCreatePipelineCache] = vkb_sv_vkCreatePipelineCache, + [VKB_CMD_vkCreatePipelineLayout] = vkb_sv_vkCreatePipelineLayout, + [VKB_CMD_vkCreateQueryPool] = vkb_sv_vkCreateQueryPool, + [VKB_CMD_vkCreateRenderPass] = vkb_sv_vkCreateRenderPass, + [VKB_CMD_vkCreateRenderPass2] = vkb_sv_vkCreateRenderPass2, + [VKB_CMD_vkCreateSampler] = vkb_sv_vkCreateSampler, + [VKB_CMD_vkCreateSamplerYcbcrConversion] = vkb_sv_vkCreateSamplerYcbcrConversion, + [VKB_CMD_vkCreateSemaphore] = vkb_sv_vkCreateSemaphore, + [VKB_CMD_vkCreateShaderModule] = vkb_sv_vkCreateShaderModule, + [VKB_CMD_vkDestroyBuffer] = vkb_sv_vkDestroyBuffer, + [VKB_CMD_vkDestroyBufferView] = vkb_sv_vkDestroyBufferView, + [VKB_CMD_vkDestroyCommandPool] = vkb_sv_vkDestroyCommandPool, + [VKB_CMD_vkDestroyDescriptorPool] = vkb_sv_vkDestroyDescriptorPool, + [VKB_CMD_vkDestroyDescriptorSetLayout] = vkb_sv_vkDestroyDescriptorSetLayout, + [VKB_CMD_vkDestroyDescriptorUpdateTemplate] = vkb_sv_vkDestroyDescriptorUpdateTemplate, + [VKB_CMD_vkDestroyDevice] = vkb_sv_vkDestroyDevice, + [VKB_CMD_vkDestroyEvent] = vkb_sv_vkDestroyEvent, + [VKB_CMD_vkDestroyFence] = vkb_sv_vkDestroyFence, + [VKB_CMD_vkDestroyFramebuffer] = vkb_sv_vkDestroyFramebuffer, + [VKB_CMD_vkDestroyImage] = vkb_sv_vkDestroyImage, + [VKB_CMD_vkDestroyImageView] = vkb_sv_vkDestroyImageView, + [VKB_CMD_vkDestroyInstance] = vkb_sv_vkDestroyInstance, + [VKB_CMD_vkDestroyPipeline] = vkb_sv_vkDestroyPipeline, + [VKB_CMD_vkDestroyPipelineCache] = vkb_sv_vkDestroyPipelineCache, + [VKB_CMD_vkDestroyPipelineLayout] = vkb_sv_vkDestroyPipelineLayout, + [VKB_CMD_vkDestroyQueryPool] = vkb_sv_vkDestroyQueryPool, + [VKB_CMD_vkDestroyRenderPass] = vkb_sv_vkDestroyRenderPass, + [VKB_CMD_vkDestroySampler] = vkb_sv_vkDestroySampler, + [VKB_CMD_vkDestroySamplerYcbcrConversion] = vkb_sv_vkDestroySamplerYcbcrConversion, + [VKB_CMD_vkDestroySemaphore] = vkb_sv_vkDestroySemaphore, + [VKB_CMD_vkDestroyShaderModule] = vkb_sv_vkDestroyShaderModule, + [VKB_CMD_vkDeviceWaitIdle] = vkb_sv_vkDeviceWaitIdle, + [VKB_CMD_vkEndCommandBuffer] = vkb_sv_vkEndCommandBuffer, + [VKB_CMD_vkEnumerateDeviceExtensionProperties] = vkb_sv_vkEnumerateDeviceExtensionProperties, + [VKB_CMD_vkEnumerateInstanceExtensionProperties] = vkb_sv_vkEnumerateInstanceExtensionProperties, + [VKB_CMD_vkEnumerateInstanceLayerProperties] = vkb_sv_vkEnumerateInstanceLayerProperties, + [VKB_CMD_vkEnumerateInstanceVersion] = vkb_sv_vkEnumerateInstanceVersion, + [VKB_CMD_vkEnumeratePhysicalDeviceGroups] = vkb_sv_vkEnumeratePhysicalDeviceGroups, + [VKB_CMD_vkEnumeratePhysicalDevices] = vkb_sv_vkEnumeratePhysicalDevices, + [VKB_CMD_vkFlushMappedMemoryRanges] = vkb_sv_vkFlushMappedMemoryRanges, + [VKB_CMD_vkFreeCommandBuffers] = vkb_sv_vkFreeCommandBuffers, + [VKB_CMD_vkFreeDescriptorSets] = vkb_sv_vkFreeDescriptorSets, + [VKB_CMD_vkFreeMemory] = vkb_sv_vkFreeMemory, + [VKB_CMD_vkGetBufferDeviceAddress] = vkb_sv_vkGetBufferDeviceAddress, + [VKB_CMD_vkGetBufferMemoryRequirements] = vkb_sv_vkGetBufferMemoryRequirements, + [VKB_CMD_vkGetBufferMemoryRequirements2] = vkb_sv_vkGetBufferMemoryRequirements2, + [VKB_CMD_vkGetBufferOpaqueCaptureAddress] = vkb_sv_vkGetBufferOpaqueCaptureAddress, + [VKB_CMD_vkGetCalibratedTimestampsEXT] = vkb_sv_vkGetCalibratedTimestampsEXT, + [VKB_CMD_vkGetDescriptorSetLayoutSupport] = vkb_sv_vkGetDescriptorSetLayoutSupport, + [VKB_CMD_vkGetDeviceBufferMemoryRequirements] = vkb_sv_vkGetDeviceBufferMemoryRequirements, + [VKB_CMD_vkGetDeviceGroupPeerMemoryFeatures] = vkb_sv_vkGetDeviceGroupPeerMemoryFeatures, + [VKB_CMD_vkGetDeviceImageMemoryRequirements] = vkb_sv_vkGetDeviceImageMemoryRequirements, + [VKB_CMD_vkGetDeviceImageSparseMemoryRequirements] = vkb_sv_vkGetDeviceImageSparseMemoryRequirements, + [VKB_CMD_vkGetDeviceMemoryCommitment] = vkb_sv_vkGetDeviceMemoryCommitment, + [VKB_CMD_vkGetDeviceMemoryOpaqueCaptureAddress] = vkb_sv_vkGetDeviceMemoryOpaqueCaptureAddress, + [VKB_CMD_vkGetDeviceQueue] = vkb_sv_vkGetDeviceQueue, + [VKB_CMD_vkGetDeviceQueue2] = vkb_sv_vkGetDeviceQueue2, + [VKB_CMD_vkGetEventStatus] = vkb_sv_vkGetEventStatus, + [VKB_CMD_vkGetFenceFdKHR] = vkb_sv_vkGetFenceFdKHR, + [VKB_CMD_vkGetFenceStatus] = vkb_sv_vkGetFenceStatus, + [VKB_CMD_vkGetImageDrmFormatModifierPropertiesEXT] = vkb_sv_vkGetImageDrmFormatModifierPropertiesEXT, + [VKB_CMD_vkGetImageMemoryRequirements] = vkb_sv_vkGetImageMemoryRequirements, + [VKB_CMD_vkGetImageMemoryRequirements2] = vkb_sv_vkGetImageMemoryRequirements2, + [VKB_CMD_vkGetImageSparseMemoryRequirements] = vkb_sv_vkGetImageSparseMemoryRequirements, + [VKB_CMD_vkGetImageSparseMemoryRequirements2] = vkb_sv_vkGetImageSparseMemoryRequirements2, + [VKB_CMD_vkGetImageSubresourceLayout] = vkb_sv_vkGetImageSubresourceLayout, + [VKB_CMD_vkGetImageSubresourceLayout2EXT] = vkb_sv_vkGetImageSubresourceLayout2EXT, + [VKB_CMD_vkGetMemoryFdKHR] = vkb_sv_vkGetMemoryFdKHR, + [VKB_CMD_vkGetMemoryFdPropertiesKHR] = vkb_sv_vkGetMemoryFdPropertiesKHR, + [VKB_CMD_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT] = vkb_sv_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, + [VKB_CMD_vkGetPhysicalDeviceExternalBufferProperties] = vkb_sv_vkGetPhysicalDeviceExternalBufferProperties, + [VKB_CMD_vkGetPhysicalDeviceExternalFenceProperties] = vkb_sv_vkGetPhysicalDeviceExternalFenceProperties, + [VKB_CMD_vkGetPhysicalDeviceExternalSemaphoreProperties] = vkb_sv_vkGetPhysicalDeviceExternalSemaphoreProperties, + [VKB_CMD_vkGetPhysicalDeviceFeatures] = vkb_sv_vkGetPhysicalDeviceFeatures, + [VKB_CMD_vkGetPhysicalDeviceFeatures2] = vkb_sv_vkGetPhysicalDeviceFeatures2, + [VKB_CMD_vkGetPhysicalDeviceFormatProperties] = vkb_sv_vkGetPhysicalDeviceFormatProperties, + [VKB_CMD_vkGetPhysicalDeviceFormatProperties2] = vkb_sv_vkGetPhysicalDeviceFormatProperties2, + [VKB_CMD_vkGetPhysicalDeviceFragmentShadingRatesKHR] = vkb_sv_vkGetPhysicalDeviceFragmentShadingRatesKHR, + [VKB_CMD_vkGetPhysicalDeviceImageFormatProperties] = vkb_sv_vkGetPhysicalDeviceImageFormatProperties, + [VKB_CMD_vkGetPhysicalDeviceImageFormatProperties2] = vkb_sv_vkGetPhysicalDeviceImageFormatProperties2, + [VKB_CMD_vkGetPhysicalDeviceMemoryProperties] = vkb_sv_vkGetPhysicalDeviceMemoryProperties, + [VKB_CMD_vkGetPhysicalDeviceMemoryProperties2] = vkb_sv_vkGetPhysicalDeviceMemoryProperties2, + [VKB_CMD_vkGetPhysicalDeviceMultisamplePropertiesEXT] = vkb_sv_vkGetPhysicalDeviceMultisamplePropertiesEXT, + [VKB_CMD_vkGetPhysicalDeviceProperties] = vkb_sv_vkGetPhysicalDeviceProperties, + [VKB_CMD_vkGetPhysicalDeviceProperties2] = vkb_sv_vkGetPhysicalDeviceProperties2, + [VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties] = vkb_sv_vkGetPhysicalDeviceQueueFamilyProperties, + [VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties2] = vkb_sv_vkGetPhysicalDeviceQueueFamilyProperties2, + [VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties] = vkb_sv_vkGetPhysicalDeviceSparseImageFormatProperties, + [VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties2] = vkb_sv_vkGetPhysicalDeviceSparseImageFormatProperties2, + [VKB_CMD_vkGetPhysicalDeviceToolProperties] = vkb_sv_vkGetPhysicalDeviceToolProperties, + [VKB_CMD_vkGetPipelineCacheData] = vkb_sv_vkGetPipelineCacheData, + [VKB_CMD_vkGetQueryPoolResults] = vkb_sv_vkGetQueryPoolResults, + [VKB_CMD_vkGetRenderAreaGranularity] = vkb_sv_vkGetRenderAreaGranularity, + [VKB_CMD_vkGetSemaphoreCounterValue] = vkb_sv_vkGetSemaphoreCounterValue, + [VKB_CMD_vkGetSemaphoreFdKHR] = vkb_sv_vkGetSemaphoreFdKHR, + [VKB_CMD_vkGetShaderModuleCreateInfoIdentifierEXT] = vkb_sv_vkGetShaderModuleCreateInfoIdentifierEXT, + [VKB_CMD_vkGetShaderModuleIdentifierEXT] = vkb_sv_vkGetShaderModuleIdentifierEXT, + [VKB_CMD_vkImportFenceFdKHR] = vkb_sv_vkImportFenceFdKHR, + [VKB_CMD_vkImportSemaphoreFdKHR] = vkb_sv_vkImportSemaphoreFdKHR, + [VKB_CMD_vkInvalidateMappedMemoryRanges] = vkb_sv_vkInvalidateMappedMemoryRanges, + [VKB_CMD_vkMergePipelineCaches] = vkb_sv_vkMergePipelineCaches, + [VKB_CMD_vkQueueBindSparse] = vkb_sv_vkQueueBindSparse, + [VKB_CMD_vkQueueSubmit] = vkb_sv_vkQueueSubmit, + [VKB_CMD_vkQueueSubmit2] = vkb_sv_vkQueueSubmit2, + [VKB_CMD_vkQueueWaitIdle] = vkb_sv_vkQueueWaitIdle, + [VKB_CMD_vkResetCommandBuffer] = vkb_sv_vkResetCommandBuffer, + [VKB_CMD_vkResetCommandPool] = vkb_sv_vkResetCommandPool, + [VKB_CMD_vkResetDescriptorPool] = vkb_sv_vkResetDescriptorPool, + [VKB_CMD_vkResetEvent] = vkb_sv_vkResetEvent, + [VKB_CMD_vkResetFences] = vkb_sv_vkResetFences, + [VKB_CMD_vkResetQueryPool] = vkb_sv_vkResetQueryPool, + [VKB_CMD_vkSetDeviceMemoryPriorityEXT] = vkb_sv_vkSetDeviceMemoryPriorityEXT, + [VKB_CMD_vkSetEvent] = vkb_sv_vkSetEvent, + [VKB_CMD_vkSignalSemaphore] = vkb_sv_vkSignalSemaphore, + [VKB_CMD_vkTrimCommandPool] = vkb_sv_vkTrimCommandPool, + [VKB_CMD_vkUpdateDescriptorSets] = vkb_sv_vkUpdateDescriptorSets, + [VKB_CMD_vkWaitForFences] = vkb_sv_vkWaitForFences, + [VKB_CMD_vkWaitSemaphores] = vkb_sv_vkWaitSemaphores, +}; diff --git a/tools/vkbridge/common/gen/vkb_gen_structs.c b/tools/vkbridge/common/gen/vkb_gen_structs.c new file mode 100644 index 000000000..f73e9763c --- /dev/null +++ b/tools/vkbridge/common/gen/vkb_gen_structs.c @@ -0,0 +1,12361 @@ +/* Generated by tools/vkbridge/codegen/gen_vkbridge.py from vk.xml 1.3.247 - do not edit. */ + +#include "vkb_gen.h" +#include "../vkb_wire.h" +#include + +void vkb_encfix_VkApplicationInfo(vkb_enc *e, const VkApplicationInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_enc_str(e, s->pApplicationName ? s->pApplicationName : NULL); + vkb_enc_str(e, s->pEngineName ? s->pEngineName : NULL); +} + +void vkb_enc_VkApplicationInfo(vkb_enc *e, const VkApplicationInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkApplicationInfo(e, s, raw); +} + +void vkb_decfix_VkApplicationInfo(vkb_dec *d, VkApplicationInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + s->pApplicationName = vkb_dec_str(d); + s->pEngineName = vkb_dec_str(d); +} + +void vkb_dec_VkApplicationInfo(vkb_dec *d, VkApplicationInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkApplicationInfo(d, s); +} + +void vkb_encfix_VkAttachmentDescription2(vkb_enc *e, const VkAttachmentDescription2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkAttachmentDescription2(vkb_enc *e, const VkAttachmentDescription2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkAttachmentDescription2(e, s, raw); +} + +void vkb_decfix_VkAttachmentDescription2(vkb_dec *d, VkAttachmentDescription2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkAttachmentDescription2(vkb_dec *d, VkAttachmentDescription2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkAttachmentDescription2(d, s); +} + +void vkb_encfix_VkAttachmentDescriptionStencilLayout(vkb_enc *e, const VkAttachmentDescriptionStencilLayout *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkAttachmentDescriptionStencilLayout(vkb_enc *e, const VkAttachmentDescriptionStencilLayout *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkAttachmentDescriptionStencilLayout(e, s, raw); +} + +void vkb_decfix_VkAttachmentDescriptionStencilLayout(vkb_dec *d, VkAttachmentDescriptionStencilLayout *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkAttachmentDescriptionStencilLayout(vkb_dec *d, VkAttachmentDescriptionStencilLayout *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkAttachmentDescriptionStencilLayout(d, s); +} + +void vkb_encfix_VkAttachmentReference2(vkb_enc *e, const VkAttachmentReference2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkAttachmentReference2(vkb_enc *e, const VkAttachmentReference2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkAttachmentReference2(e, s, raw); +} + +void vkb_decfix_VkAttachmentReference2(vkb_dec *d, VkAttachmentReference2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkAttachmentReference2(vkb_dec *d, VkAttachmentReference2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkAttachmentReference2(d, s); +} + +void vkb_encfix_VkAttachmentReferenceStencilLayout(vkb_enc *e, const VkAttachmentReferenceStencilLayout *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkAttachmentReferenceStencilLayout(vkb_enc *e, const VkAttachmentReferenceStencilLayout *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkAttachmentReferenceStencilLayout(e, s, raw); +} + +void vkb_decfix_VkAttachmentReferenceStencilLayout(vkb_dec *d, VkAttachmentReferenceStencilLayout *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkAttachmentReferenceStencilLayout(vkb_dec *d, VkAttachmentReferenceStencilLayout *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkAttachmentReferenceStencilLayout(d, s); +} + +void vkb_encfix_VkAttachmentSampleLocationsEXT(vkb_enc *e, const VkAttachmentSampleLocationsEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_encfix_VkSampleLocationsInfoEXT(e, &s->sampleLocationsInfo, raw + offsetof(VkAttachmentSampleLocationsEXT, sampleLocationsInfo)); +} + +void vkb_enc_VkAttachmentSampleLocationsEXT(vkb_enc *e, const VkAttachmentSampleLocationsEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkAttachmentSampleLocationsEXT(e, s, raw); +} + +void vkb_decfix_VkAttachmentSampleLocationsEXT(vkb_dec *d, VkAttachmentSampleLocationsEXT *s) +{ + (void)d; (void)s; + vkb_decfix_VkSampleLocationsInfoEXT(d, &s->sampleLocationsInfo); +} + +void vkb_dec_VkAttachmentSampleLocationsEXT(vkb_dec *d, VkAttachmentSampleLocationsEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkAttachmentSampleLocationsEXT(d, s); +} + +void vkb_encfix_VkBindBufferMemoryDeviceGroupInfo(vkb_enc *e, const VkBindBufferMemoryDeviceGroupInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pDeviceIndices) { + uint32_t n_ = (uint32_t)(s->deviceIndexCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDeviceIndices, (size_t)n_ * sizeof(*s->pDeviceIndices)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkBindBufferMemoryDeviceGroupInfo(vkb_enc *e, const VkBindBufferMemoryDeviceGroupInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBindBufferMemoryDeviceGroupInfo(e, s, raw); +} + +void vkb_decfix_VkBindBufferMemoryDeviceGroupInfo(vkb_dec *d, VkBindBufferMemoryDeviceGroupInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDeviceIndices = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pDeviceIndices = NULL; + } +} + +void vkb_dec_VkBindBufferMemoryDeviceGroupInfo(vkb_dec *d, VkBindBufferMemoryDeviceGroupInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBindBufferMemoryDeviceGroupInfo(d, s); +} + +void vkb_encfix_VkBindBufferMemoryInfo(vkb_enc *e, const VkBindBufferMemoryInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBindBufferMemoryInfo(vkb_enc *e, const VkBindBufferMemoryInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBindBufferMemoryInfo(e, s, raw); +} + +void vkb_decfix_VkBindBufferMemoryInfo(vkb_dec *d, VkBindBufferMemoryInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBindBufferMemoryInfo(vkb_dec *d, VkBindBufferMemoryInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBindBufferMemoryInfo(d, s); +} + +void vkb_encfix_VkBindImageMemoryDeviceGroupInfo(vkb_enc *e, const VkBindImageMemoryDeviceGroupInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pDeviceIndices) { + uint32_t n_ = (uint32_t)(s->deviceIndexCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDeviceIndices, (size_t)n_ * sizeof(*s->pDeviceIndices)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pSplitInstanceBindRegions) { + uint32_t n_ = (uint32_t)(s->splitInstanceBindRegionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pSplitInstanceBindRegions, (size_t)n_ * sizeof(*s->pSplitInstanceBindRegions)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkBindImageMemoryDeviceGroupInfo(vkb_enc *e, const VkBindImageMemoryDeviceGroupInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBindImageMemoryDeviceGroupInfo(e, s, raw); +} + +void vkb_decfix_VkBindImageMemoryDeviceGroupInfo(vkb_dec *d, VkBindImageMemoryDeviceGroupInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDeviceIndices = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pDeviceIndices = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pSplitInstanceBindRegions = (const VkRect2D *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkRect2D)); + } else { + s->pSplitInstanceBindRegions = NULL; + } +} + +void vkb_dec_VkBindImageMemoryDeviceGroupInfo(vkb_dec *d, VkBindImageMemoryDeviceGroupInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBindImageMemoryDeviceGroupInfo(d, s); +} + +void vkb_encfix_VkBindImageMemoryInfo(vkb_enc *e, const VkBindImageMemoryInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBindImageMemoryInfo(vkb_enc *e, const VkBindImageMemoryInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBindImageMemoryInfo(e, s, raw); +} + +void vkb_decfix_VkBindImageMemoryInfo(vkb_dec *d, VkBindImageMemoryInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBindImageMemoryInfo(vkb_dec *d, VkBindImageMemoryInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBindImageMemoryInfo(d, s); +} + +void vkb_encfix_VkBindImageMemorySwapchainInfoKHR(vkb_enc *e, const VkBindImageMemorySwapchainInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBindImageMemorySwapchainInfoKHR(vkb_enc *e, const VkBindImageMemorySwapchainInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBindImageMemorySwapchainInfoKHR(e, s, raw); +} + +void vkb_decfix_VkBindImageMemorySwapchainInfoKHR(vkb_dec *d, VkBindImageMemorySwapchainInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBindImageMemorySwapchainInfoKHR(vkb_dec *d, VkBindImageMemorySwapchainInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBindImageMemorySwapchainInfoKHR(d, s); +} + +void vkb_encfix_VkBindImagePlaneMemoryInfo(vkb_enc *e, const VkBindImagePlaneMemoryInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBindImagePlaneMemoryInfo(vkb_enc *e, const VkBindImagePlaneMemoryInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBindImagePlaneMemoryInfo(e, s, raw); +} + +void vkb_decfix_VkBindImagePlaneMemoryInfo(vkb_dec *d, VkBindImagePlaneMemoryInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBindImagePlaneMemoryInfo(vkb_dec *d, VkBindImagePlaneMemoryInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBindImagePlaneMemoryInfo(d, s); +} + +void vkb_encfix_VkBindSparseInfo(vkb_enc *e, const VkBindSparseInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pWaitSemaphores) { + uint32_t n_ = (uint32_t)(s->waitSemaphoreCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pWaitSemaphores, (size_t)n_ * sizeof(*s->pWaitSemaphores)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pBufferBinds) { + uint32_t n_ = (uint32_t)(s->bufferBindCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSparseBufferMemoryBindInfo(e, &s->pBufferBinds[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pImageOpaqueBinds) { + uint32_t n_ = (uint32_t)(s->imageOpaqueBindCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSparseImageOpaqueMemoryBindInfo(e, &s->pImageOpaqueBinds[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pImageBinds) { + uint32_t n_ = (uint32_t)(s->imageBindCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSparseImageMemoryBindInfo(e, &s->pImageBinds[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pSignalSemaphores) { + uint32_t n_ = (uint32_t)(s->signalSemaphoreCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pSignalSemaphores, (size_t)n_ * sizeof(*s->pSignalSemaphores)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkBindSparseInfo(vkb_enc *e, const VkBindSparseInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBindSparseInfo(e, s, raw); +} + +void vkb_decfix_VkBindSparseInfo(vkb_dec *d, VkBindSparseInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pWaitSemaphores = (const VkSemaphore *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSemaphore)); + } else { + s->pWaitSemaphores = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSparseBufferMemoryBindInfo *a_ = (VkSparseBufferMemoryBindInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSparseBufferMemoryBindInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSparseBufferMemoryBindInfo(d, &a_[i_]); + s->pBufferBinds = a_; + } else { + s->pBufferBinds = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSparseImageOpaqueMemoryBindInfo *a_ = (VkSparseImageOpaqueMemoryBindInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSparseImageOpaqueMemoryBindInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSparseImageOpaqueMemoryBindInfo(d, &a_[i_]); + s->pImageOpaqueBinds = a_; + } else { + s->pImageOpaqueBinds = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSparseImageMemoryBindInfo *a_ = (VkSparseImageMemoryBindInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSparseImageMemoryBindInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSparseImageMemoryBindInfo(d, &a_[i_]); + s->pImageBinds = a_; + } else { + s->pImageBinds = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pSignalSemaphores = (const VkSemaphore *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSemaphore)); + } else { + s->pSignalSemaphores = NULL; + } +} + +void vkb_dec_VkBindSparseInfo(vkb_dec *d, VkBindSparseInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBindSparseInfo(d, s); +} + +void vkb_encfix_VkBlitImageInfo2(vkb_enc *e, const VkBlitImageInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pRegions) { + uint32_t n_ = (uint32_t)(s->regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageBlit2(e, &s->pRegions[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkBlitImageInfo2(vkb_enc *e, const VkBlitImageInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBlitImageInfo2(e, s, raw); +} + +void vkb_decfix_VkBlitImageInfo2(vkb_dec *d, VkBlitImageInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageBlit2 *a_ = (VkImageBlit2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageBlit2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageBlit2(d, &a_[i_]); + s->pRegions = a_; + } else { + s->pRegions = NULL; + } +} + +void vkb_dec_VkBlitImageInfo2(vkb_dec *d, VkBlitImageInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBlitImageInfo2(d, s); +} + +void vkb_encfix_VkBufferCopy2(vkb_enc *e, const VkBufferCopy2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBufferCopy2(vkb_enc *e, const VkBufferCopy2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBufferCopy2(e, s, raw); +} + +void vkb_decfix_VkBufferCopy2(vkb_dec *d, VkBufferCopy2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBufferCopy2(vkb_dec *d, VkBufferCopy2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBufferCopy2(d, s); +} + +void vkb_encfix_VkBufferCreateInfo(vkb_enc *e, const VkBufferCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pQueueFamilyIndices && (s->sharingMode == VK_SHARING_MODE_CONCURRENT)) { + uint32_t n_ = (uint32_t)(s->queueFamilyIndexCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pQueueFamilyIndices, (size_t)n_ * sizeof(*s->pQueueFamilyIndices)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkBufferCreateInfo(vkb_enc *e, const VkBufferCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBufferCreateInfo(e, s, raw); +} + +void vkb_decfix_VkBufferCreateInfo(vkb_dec *d, VkBufferCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pQueueFamilyIndices = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pQueueFamilyIndices = NULL; + } +} + +void vkb_dec_VkBufferCreateInfo(vkb_dec *d, VkBufferCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBufferCreateInfo(d, s); +} + +void vkb_encfix_VkBufferDeviceAddressCreateInfoEXT(vkb_enc *e, const VkBufferDeviceAddressCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBufferDeviceAddressCreateInfoEXT(vkb_enc *e, const VkBufferDeviceAddressCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBufferDeviceAddressCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkBufferDeviceAddressCreateInfoEXT(vkb_dec *d, VkBufferDeviceAddressCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBufferDeviceAddressCreateInfoEXT(vkb_dec *d, VkBufferDeviceAddressCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBufferDeviceAddressCreateInfoEXT(d, s); +} + +void vkb_encfix_VkBufferDeviceAddressInfo(vkb_enc *e, const VkBufferDeviceAddressInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBufferDeviceAddressInfo(vkb_enc *e, const VkBufferDeviceAddressInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBufferDeviceAddressInfo(e, s, raw); +} + +void vkb_decfix_VkBufferDeviceAddressInfo(vkb_dec *d, VkBufferDeviceAddressInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBufferDeviceAddressInfo(vkb_dec *d, VkBufferDeviceAddressInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBufferDeviceAddressInfo(d, s); +} + +void vkb_encfix_VkBufferImageCopy2(vkb_enc *e, const VkBufferImageCopy2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBufferImageCopy2(vkb_enc *e, const VkBufferImageCopy2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBufferImageCopy2(e, s, raw); +} + +void vkb_decfix_VkBufferImageCopy2(vkb_dec *d, VkBufferImageCopy2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBufferImageCopy2(vkb_dec *d, VkBufferImageCopy2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBufferImageCopy2(d, s); +} + +void vkb_encfix_VkBufferMemoryBarrier(vkb_enc *e, const VkBufferMemoryBarrier *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBufferMemoryBarrier(vkb_enc *e, const VkBufferMemoryBarrier *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBufferMemoryBarrier(e, s, raw); +} + +void vkb_decfix_VkBufferMemoryBarrier(vkb_dec *d, VkBufferMemoryBarrier *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBufferMemoryBarrier(vkb_dec *d, VkBufferMemoryBarrier *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBufferMemoryBarrier(d, s); +} + +void vkb_encfix_VkBufferMemoryBarrier2(vkb_enc *e, const VkBufferMemoryBarrier2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBufferMemoryBarrier2(vkb_enc *e, const VkBufferMemoryBarrier2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBufferMemoryBarrier2(e, s, raw); +} + +void vkb_decfix_VkBufferMemoryBarrier2(vkb_dec *d, VkBufferMemoryBarrier2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBufferMemoryBarrier2(vkb_dec *d, VkBufferMemoryBarrier2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBufferMemoryBarrier2(d, s); +} + +void vkb_encfix_VkBufferMemoryRequirementsInfo2(vkb_enc *e, const VkBufferMemoryRequirementsInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBufferMemoryRequirementsInfo2(vkb_enc *e, const VkBufferMemoryRequirementsInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBufferMemoryRequirementsInfo2(e, s, raw); +} + +void vkb_decfix_VkBufferMemoryRequirementsInfo2(vkb_dec *d, VkBufferMemoryRequirementsInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBufferMemoryRequirementsInfo2(vkb_dec *d, VkBufferMemoryRequirementsInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBufferMemoryRequirementsInfo2(d, s); +} + +void vkb_encfix_VkBufferOpaqueCaptureAddressCreateInfo(vkb_enc *e, const VkBufferOpaqueCaptureAddressCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBufferOpaqueCaptureAddressCreateInfo(vkb_enc *e, const VkBufferOpaqueCaptureAddressCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBufferOpaqueCaptureAddressCreateInfo(e, s, raw); +} + +void vkb_decfix_VkBufferOpaqueCaptureAddressCreateInfo(vkb_dec *d, VkBufferOpaqueCaptureAddressCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBufferOpaqueCaptureAddressCreateInfo(vkb_dec *d, VkBufferOpaqueCaptureAddressCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBufferOpaqueCaptureAddressCreateInfo(d, s); +} + +void vkb_encfix_VkBufferViewCreateInfo(vkb_enc *e, const VkBufferViewCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkBufferViewCreateInfo(vkb_enc *e, const VkBufferViewCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkBufferViewCreateInfo(e, s, raw); +} + +void vkb_decfix_VkBufferViewCreateInfo(vkb_dec *d, VkBufferViewCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkBufferViewCreateInfo(vkb_dec *d, VkBufferViewCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkBufferViewCreateInfo(d, s); +} + +void vkb_encfix_VkCalibratedTimestampInfoEXT(vkb_enc *e, const VkCalibratedTimestampInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkCalibratedTimestampInfoEXT(vkb_enc *e, const VkCalibratedTimestampInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCalibratedTimestampInfoEXT(e, s, raw); +} + +void vkb_decfix_VkCalibratedTimestampInfoEXT(vkb_dec *d, VkCalibratedTimestampInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkCalibratedTimestampInfoEXT(vkb_dec *d, VkCalibratedTimestampInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCalibratedTimestampInfoEXT(d, s); +} + +void vkb_encfix_VkCommandBufferAllocateInfo(vkb_enc *e, const VkCommandBufferAllocateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkCommandBufferAllocateInfo(vkb_enc *e, const VkCommandBufferAllocateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCommandBufferAllocateInfo(e, s, raw); +} + +void vkb_decfix_VkCommandBufferAllocateInfo(vkb_dec *d, VkCommandBufferAllocateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkCommandBufferAllocateInfo(vkb_dec *d, VkCommandBufferAllocateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCommandBufferAllocateInfo(d, s); +} + +void vkb_encfix_VkCommandBufferBeginInfo(vkb_enc *e, const VkCommandBufferBeginInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pInheritanceInfo && (vkb_cb_begin_is_secondary(s))) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkCommandBufferInheritanceInfo(e, &s->pInheritanceInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkCommandBufferBeginInfo(vkb_enc *e, const VkCommandBufferBeginInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCommandBufferBeginInfo(e, s, raw); +} + +void vkb_decfix_VkCommandBufferBeginInfo(vkb_dec *d, VkCommandBufferBeginInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCommandBufferInheritanceInfo *a_ = (VkCommandBufferInheritanceInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCommandBufferInheritanceInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkCommandBufferInheritanceInfo(d, &a_[i_]); + s->pInheritanceInfo = a_; + } else { + s->pInheritanceInfo = NULL; + } +} + +void vkb_dec_VkCommandBufferBeginInfo(vkb_dec *d, VkCommandBufferBeginInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCommandBufferBeginInfo(d, s); +} + +void vkb_encfix_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkb_enc *e, const VkCommandBufferInheritanceConditionalRenderingInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkb_enc *e, const VkCommandBufferInheritanceConditionalRenderingInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCommandBufferInheritanceConditionalRenderingInfoEXT(e, s, raw); +} + +void vkb_decfix_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkb_dec *d, VkCommandBufferInheritanceConditionalRenderingInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkb_dec *d, VkCommandBufferInheritanceConditionalRenderingInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCommandBufferInheritanceConditionalRenderingInfoEXT(d, s); +} + +void vkb_encfix_VkCommandBufferInheritanceInfo(vkb_enc *e, const VkCommandBufferInheritanceInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkCommandBufferInheritanceInfo(vkb_enc *e, const VkCommandBufferInheritanceInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCommandBufferInheritanceInfo(e, s, raw); +} + +void vkb_decfix_VkCommandBufferInheritanceInfo(vkb_dec *d, VkCommandBufferInheritanceInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkCommandBufferInheritanceInfo(vkb_dec *d, VkCommandBufferInheritanceInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCommandBufferInheritanceInfo(d, s); +} + +void vkb_encfix_VkCommandBufferInheritanceRenderingInfo(vkb_enc *e, const VkCommandBufferInheritanceRenderingInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pColorAttachmentFormats) { + uint32_t n_ = (uint32_t)(s->colorAttachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pColorAttachmentFormats, (size_t)n_ * sizeof(*s->pColorAttachmentFormats)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkCommandBufferInheritanceRenderingInfo(vkb_enc *e, const VkCommandBufferInheritanceRenderingInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCommandBufferInheritanceRenderingInfo(e, s, raw); +} + +void vkb_decfix_VkCommandBufferInheritanceRenderingInfo(vkb_dec *d, VkCommandBufferInheritanceRenderingInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pColorAttachmentFormats = (const VkFormat *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkFormat)); + } else { + s->pColorAttachmentFormats = NULL; + } +} + +void vkb_dec_VkCommandBufferInheritanceRenderingInfo(vkb_dec *d, VkCommandBufferInheritanceRenderingInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCommandBufferInheritanceRenderingInfo(d, s); +} + +void vkb_encfix_VkCommandBufferSubmitInfo(vkb_enc *e, const VkCommandBufferSubmitInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_enc_patch_u64(e, raw + offsetof(VkCommandBufferSubmitInfo, commandBuffer), vkb_remote((const void *)s->commandBuffer)); +} + +void vkb_enc_VkCommandBufferSubmitInfo(vkb_enc *e, const VkCommandBufferSubmitInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCommandBufferSubmitInfo(e, s, raw); +} + +void vkb_decfix_VkCommandBufferSubmitInfo(vkb_dec *d, VkCommandBufferSubmitInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkCommandBufferSubmitInfo(vkb_dec *d, VkCommandBufferSubmitInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCommandBufferSubmitInfo(d, s); +} + +void vkb_encfix_VkCommandPoolCreateInfo(vkb_enc *e, const VkCommandPoolCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkCommandPoolCreateInfo(vkb_enc *e, const VkCommandPoolCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCommandPoolCreateInfo(e, s, raw); +} + +void vkb_decfix_VkCommandPoolCreateInfo(vkb_dec *d, VkCommandPoolCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkCommandPoolCreateInfo(vkb_dec *d, VkCommandPoolCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCommandPoolCreateInfo(d, s); +} + +void vkb_encfix_VkComputePipelineCreateInfo(vkb_enc *e, const VkComputePipelineCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_encfix_VkPipelineShaderStageCreateInfo(e, &s->stage, raw + offsetof(VkComputePipelineCreateInfo, stage)); +} + +void vkb_enc_VkComputePipelineCreateInfo(vkb_enc *e, const VkComputePipelineCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkComputePipelineCreateInfo(e, s, raw); +} + +void vkb_decfix_VkComputePipelineCreateInfo(vkb_dec *d, VkComputePipelineCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + vkb_decfix_VkPipelineShaderStageCreateInfo(d, &s->stage); +} + +void vkb_dec_VkComputePipelineCreateInfo(vkb_dec *d, VkComputePipelineCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkComputePipelineCreateInfo(d, s); +} + +void vkb_encfix_VkConditionalRenderingBeginInfoEXT(vkb_enc *e, const VkConditionalRenderingBeginInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkConditionalRenderingBeginInfoEXT(vkb_enc *e, const VkConditionalRenderingBeginInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkConditionalRenderingBeginInfoEXT(e, s, raw); +} + +void vkb_decfix_VkConditionalRenderingBeginInfoEXT(vkb_dec *d, VkConditionalRenderingBeginInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkConditionalRenderingBeginInfoEXT(vkb_dec *d, VkConditionalRenderingBeginInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkConditionalRenderingBeginInfoEXT(d, s); +} + +void vkb_encfix_VkCopyBufferInfo2(vkb_enc *e, const VkCopyBufferInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pRegions) { + uint32_t n_ = (uint32_t)(s->regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferCopy2(e, &s->pRegions[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkCopyBufferInfo2(vkb_enc *e, const VkCopyBufferInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCopyBufferInfo2(e, s, raw); +} + +void vkb_decfix_VkCopyBufferInfo2(vkb_dec *d, VkCopyBufferInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferCopy2 *a_ = (VkBufferCopy2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferCopy2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferCopy2(d, &a_[i_]); + s->pRegions = a_; + } else { + s->pRegions = NULL; + } +} + +void vkb_dec_VkCopyBufferInfo2(vkb_dec *d, VkCopyBufferInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCopyBufferInfo2(d, s); +} + +void vkb_encfix_VkCopyBufferToImageInfo2(vkb_enc *e, const VkCopyBufferToImageInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pRegions) { + uint32_t n_ = (uint32_t)(s->regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferImageCopy2(e, &s->pRegions[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkCopyBufferToImageInfo2(vkb_enc *e, const VkCopyBufferToImageInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCopyBufferToImageInfo2(e, s, raw); +} + +void vkb_decfix_VkCopyBufferToImageInfo2(vkb_dec *d, VkCopyBufferToImageInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferImageCopy2 *a_ = (VkBufferImageCopy2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferImageCopy2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferImageCopy2(d, &a_[i_]); + s->pRegions = a_; + } else { + s->pRegions = NULL; + } +} + +void vkb_dec_VkCopyBufferToImageInfo2(vkb_dec *d, VkCopyBufferToImageInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCopyBufferToImageInfo2(d, s); +} + +void vkb_encfix_VkCopyDescriptorSet(vkb_enc *e, const VkCopyDescriptorSet *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkCopyDescriptorSet(vkb_enc *e, const VkCopyDescriptorSet *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCopyDescriptorSet(e, s, raw); +} + +void vkb_decfix_VkCopyDescriptorSet(vkb_dec *d, VkCopyDescriptorSet *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkCopyDescriptorSet(vkb_dec *d, VkCopyDescriptorSet *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCopyDescriptorSet(d, s); +} + +void vkb_encfix_VkCopyImageInfo2(vkb_enc *e, const VkCopyImageInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pRegions) { + uint32_t n_ = (uint32_t)(s->regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageCopy2(e, &s->pRegions[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkCopyImageInfo2(vkb_enc *e, const VkCopyImageInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCopyImageInfo2(e, s, raw); +} + +void vkb_decfix_VkCopyImageInfo2(vkb_dec *d, VkCopyImageInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageCopy2 *a_ = (VkImageCopy2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageCopy2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageCopy2(d, &a_[i_]); + s->pRegions = a_; + } else { + s->pRegions = NULL; + } +} + +void vkb_dec_VkCopyImageInfo2(vkb_dec *d, VkCopyImageInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCopyImageInfo2(d, s); +} + +void vkb_encfix_VkCopyImageToBufferInfo2(vkb_enc *e, const VkCopyImageToBufferInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pRegions) { + uint32_t n_ = (uint32_t)(s->regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferImageCopy2(e, &s->pRegions[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkCopyImageToBufferInfo2(vkb_enc *e, const VkCopyImageToBufferInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkCopyImageToBufferInfo2(e, s, raw); +} + +void vkb_decfix_VkCopyImageToBufferInfo2(vkb_dec *d, VkCopyImageToBufferInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferImageCopy2 *a_ = (VkBufferImageCopy2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferImageCopy2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferImageCopy2(d, &a_[i_]); + s->pRegions = a_; + } else { + s->pRegions = NULL; + } +} + +void vkb_dec_VkCopyImageToBufferInfo2(vkb_dec *d, VkCopyImageToBufferInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkCopyImageToBufferInfo2(d, s); +} + +void vkb_encfix_VkDebugUtilsObjectNameInfoEXT(vkb_enc *e, const VkDebugUtilsObjectNameInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_enc_str(e, s->pObjectName ? s->pObjectName : NULL); +} + +void vkb_enc_VkDebugUtilsObjectNameInfoEXT(vkb_enc *e, const VkDebugUtilsObjectNameInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDebugUtilsObjectNameInfoEXT(e, s, raw); +} + +void vkb_decfix_VkDebugUtilsObjectNameInfoEXT(vkb_dec *d, VkDebugUtilsObjectNameInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + s->pObjectName = vkb_dec_str(d); +} + +void vkb_dec_VkDebugUtilsObjectNameInfoEXT(vkb_dec *d, VkDebugUtilsObjectNameInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDebugUtilsObjectNameInfoEXT(d, s); +} + +void vkb_encfix_VkDependencyInfo(vkb_enc *e, const VkDependencyInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pMemoryBarriers) { + uint32_t n_ = (uint32_t)(s->memoryBarrierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkMemoryBarrier2(e, &s->pMemoryBarriers[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pBufferMemoryBarriers) { + uint32_t n_ = (uint32_t)(s->bufferMemoryBarrierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferMemoryBarrier2(e, &s->pBufferMemoryBarriers[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pImageMemoryBarriers) { + uint32_t n_ = (uint32_t)(s->imageMemoryBarrierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageMemoryBarrier2(e, &s->pImageMemoryBarriers[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDependencyInfo(vkb_enc *e, const VkDependencyInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDependencyInfo(e, s, raw); +} + +void vkb_decfix_VkDependencyInfo(vkb_dec *d, VkDependencyInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkMemoryBarrier2 *a_ = (VkMemoryBarrier2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkMemoryBarrier2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkMemoryBarrier2(d, &a_[i_]); + s->pMemoryBarriers = a_; + } else { + s->pMemoryBarriers = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferMemoryBarrier2 *a_ = (VkBufferMemoryBarrier2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferMemoryBarrier2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferMemoryBarrier2(d, &a_[i_]); + s->pBufferMemoryBarriers = a_; + } else { + s->pBufferMemoryBarriers = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageMemoryBarrier2 *a_ = (VkImageMemoryBarrier2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageMemoryBarrier2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageMemoryBarrier2(d, &a_[i_]); + s->pImageMemoryBarriers = a_; + } else { + s->pImageMemoryBarriers = NULL; + } +} + +void vkb_dec_VkDependencyInfo(vkb_dec *d, VkDependencyInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDependencyInfo(d, s); +} + +void vkb_encfix_VkDescriptorPoolCreateInfo(vkb_enc *e, const VkDescriptorPoolCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pPoolSizes) { + uint32_t n_ = (uint32_t)(s->poolSizeCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pPoolSizes, (size_t)n_ * sizeof(*s->pPoolSizes)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDescriptorPoolCreateInfo(vkb_enc *e, const VkDescriptorPoolCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDescriptorPoolCreateInfo(e, s, raw); +} + +void vkb_decfix_VkDescriptorPoolCreateInfo(vkb_dec *d, VkDescriptorPoolCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pPoolSizes = (const VkDescriptorPoolSize *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDescriptorPoolSize)); + } else { + s->pPoolSizes = NULL; + } +} + +void vkb_dec_VkDescriptorPoolCreateInfo(vkb_dec *d, VkDescriptorPoolCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDescriptorPoolCreateInfo(d, s); +} + +void vkb_encfix_VkDescriptorPoolInlineUniformBlockCreateInfo(vkb_enc *e, const VkDescriptorPoolInlineUniformBlockCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkDescriptorPoolInlineUniformBlockCreateInfo(vkb_enc *e, const VkDescriptorPoolInlineUniformBlockCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDescriptorPoolInlineUniformBlockCreateInfo(e, s, raw); +} + +void vkb_decfix_VkDescriptorPoolInlineUniformBlockCreateInfo(vkb_dec *d, VkDescriptorPoolInlineUniformBlockCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkDescriptorPoolInlineUniformBlockCreateInfo(vkb_dec *d, VkDescriptorPoolInlineUniformBlockCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDescriptorPoolInlineUniformBlockCreateInfo(d, s); +} + +void vkb_encfix_VkDescriptorSetAllocateInfo(vkb_enc *e, const VkDescriptorSetAllocateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pSetLayouts) { + uint32_t n_ = (uint32_t)(s->descriptorSetCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pSetLayouts, (size_t)n_ * sizeof(*s->pSetLayouts)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDescriptorSetAllocateInfo(vkb_enc *e, const VkDescriptorSetAllocateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDescriptorSetAllocateInfo(e, s, raw); +} + +void vkb_decfix_VkDescriptorSetAllocateInfo(vkb_dec *d, VkDescriptorSetAllocateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pSetLayouts = (const VkDescriptorSetLayout *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDescriptorSetLayout)); + } else { + s->pSetLayouts = NULL; + } +} + +void vkb_dec_VkDescriptorSetAllocateInfo(vkb_dec *d, VkDescriptorSetAllocateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDescriptorSetAllocateInfo(d, s); +} + +void vkb_encfix_VkDescriptorSetLayoutBinding(vkb_enc *e, const VkDescriptorSetLayoutBinding *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + if (s->pImmutableSamplers && ((s->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || s->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER))) { + uint32_t n_ = (uint32_t)(s->descriptorCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pImmutableSamplers, (size_t)n_ * sizeof(*s->pImmutableSamplers)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDescriptorSetLayoutBinding(vkb_enc *e, const VkDescriptorSetLayoutBinding *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDescriptorSetLayoutBinding(e, s, raw); +} + +void vkb_decfix_VkDescriptorSetLayoutBinding(vkb_dec *d, VkDescriptorSetLayoutBinding *s) +{ + (void)d; (void)s; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pImmutableSamplers = (const VkSampler *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSampler)); + } else { + s->pImmutableSamplers = NULL; + } +} + +void vkb_dec_VkDescriptorSetLayoutBinding(vkb_dec *d, VkDescriptorSetLayoutBinding *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDescriptorSetLayoutBinding(d, s); +} + +void vkb_encfix_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkb_enc *e, const VkDescriptorSetLayoutBindingFlagsCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pBindingFlags) { + uint32_t n_ = (uint32_t)(s->bindingCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pBindingFlags, (size_t)n_ * sizeof(*s->pBindingFlags)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkb_enc *e, const VkDescriptorSetLayoutBindingFlagsCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDescriptorSetLayoutBindingFlagsCreateInfo(e, s, raw); +} + +void vkb_decfix_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkb_dec *d, VkDescriptorSetLayoutBindingFlagsCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pBindingFlags = (const VkDescriptorBindingFlags *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDescriptorBindingFlags)); + } else { + s->pBindingFlags = NULL; + } +} + +void vkb_dec_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkb_dec *d, VkDescriptorSetLayoutBindingFlagsCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDescriptorSetLayoutBindingFlagsCreateInfo(d, s); +} + +void vkb_encfix_VkDescriptorSetLayoutCreateInfo(vkb_enc *e, const VkDescriptorSetLayoutCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pBindings) { + uint32_t n_ = (uint32_t)(s->bindingCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDescriptorSetLayoutBinding(e, &s->pBindings[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDescriptorSetLayoutCreateInfo(vkb_enc *e, const VkDescriptorSetLayoutCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDescriptorSetLayoutCreateInfo(e, s, raw); +} + +void vkb_decfix_VkDescriptorSetLayoutCreateInfo(vkb_dec *d, VkDescriptorSetLayoutCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDescriptorSetLayoutBinding *a_ = (VkDescriptorSetLayoutBinding *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDescriptorSetLayoutBinding)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDescriptorSetLayoutBinding(d, &a_[i_]); + s->pBindings = a_; + } else { + s->pBindings = NULL; + } +} + +void vkb_dec_VkDescriptorSetLayoutCreateInfo(vkb_dec *d, VkDescriptorSetLayoutCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDescriptorSetLayoutCreateInfo(d, s); +} + +void vkb_encfix_VkDescriptorSetLayoutSupport(vkb_enc *e, const VkDescriptorSetLayoutSupport *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkDescriptorSetLayoutSupport(vkb_enc *e, const VkDescriptorSetLayoutSupport *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDescriptorSetLayoutSupport(e, s, raw); +} + +void vkb_decfix_VkDescriptorSetLayoutSupport(vkb_dec *d, VkDescriptorSetLayoutSupport *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkDescriptorSetLayoutSupport(vkb_dec *d, VkDescriptorSetLayoutSupport *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDescriptorSetLayoutSupport(d, s); +} + +void vkb_encfix_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkb_enc *e, const VkDescriptorSetVariableDescriptorCountAllocateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pDescriptorCounts) { + uint32_t n_ = (uint32_t)(s->descriptorSetCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDescriptorCounts, (size_t)n_ * sizeof(*s->pDescriptorCounts)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkb_enc *e, const VkDescriptorSetVariableDescriptorCountAllocateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDescriptorSetVariableDescriptorCountAllocateInfo(e, s, raw); +} + +void vkb_decfix_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkb_dec *d, VkDescriptorSetVariableDescriptorCountAllocateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDescriptorCounts = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pDescriptorCounts = NULL; + } +} + +void vkb_dec_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkb_dec *d, VkDescriptorSetVariableDescriptorCountAllocateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDescriptorSetVariableDescriptorCountAllocateInfo(d, s); +} + +void vkb_encfix_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkb_enc *e, const VkDescriptorSetVariableDescriptorCountLayoutSupport *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkb_enc *e, const VkDescriptorSetVariableDescriptorCountLayoutSupport *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDescriptorSetVariableDescriptorCountLayoutSupport(e, s, raw); +} + +void vkb_decfix_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkb_dec *d, VkDescriptorSetVariableDescriptorCountLayoutSupport *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkb_dec *d, VkDescriptorSetVariableDescriptorCountLayoutSupport *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDescriptorSetVariableDescriptorCountLayoutSupport(d, s); +} + +void vkb_encfix_VkDescriptorUpdateTemplateCreateInfo(vkb_enc *e, const VkDescriptorUpdateTemplateCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pDescriptorUpdateEntries) { + uint32_t n_ = (uint32_t)(s->descriptorUpdateEntryCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDescriptorUpdateEntries, (size_t)n_ * sizeof(*s->pDescriptorUpdateEntries)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDescriptorUpdateTemplateCreateInfo(vkb_enc *e, const VkDescriptorUpdateTemplateCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDescriptorUpdateTemplateCreateInfo(e, s, raw); +} + +void vkb_decfix_VkDescriptorUpdateTemplateCreateInfo(vkb_dec *d, VkDescriptorUpdateTemplateCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDescriptorUpdateEntries = (const VkDescriptorUpdateTemplateEntry *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDescriptorUpdateTemplateEntry)); + } else { + s->pDescriptorUpdateEntries = NULL; + } +} + +void vkb_dec_VkDescriptorUpdateTemplateCreateInfo(vkb_dec *d, VkDescriptorUpdateTemplateCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDescriptorUpdateTemplateCreateInfo(d, s); +} + +void vkb_encfix_VkDeviceBufferMemoryRequirements(vkb_enc *e, const VkDeviceBufferMemoryRequirements *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkBufferCreateInfo(e, &s->pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDeviceBufferMemoryRequirements(vkb_enc *e, const VkDeviceBufferMemoryRequirements *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceBufferMemoryRequirements(e, s, raw); +} + +void vkb_decfix_VkDeviceBufferMemoryRequirements(vkb_dec *d, VkDeviceBufferMemoryRequirements *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkBufferCreateInfo *a_ = (VkBufferCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkBufferCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkBufferCreateInfo(d, &a_[i_]); + s->pCreateInfo = a_; + } else { + s->pCreateInfo = NULL; + } +} + +void vkb_dec_VkDeviceBufferMemoryRequirements(vkb_dec *d, VkDeviceBufferMemoryRequirements *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceBufferMemoryRequirements(d, s); +} + +void vkb_encfix_VkDeviceCreateInfo(vkb_enc *e, const VkDeviceCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pQueueCreateInfos) { + uint32_t n_ = (uint32_t)(s->queueCreateInfoCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkDeviceQueueCreateInfo(e, &s->pQueueCreateInfos[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_strarray(e, s->ppEnabledLayerNames ? s->ppEnabledLayerNames : NULL, s->ppEnabledLayerNames ? (uint32_t)(s->enabledLayerCount) : 0); + vkb_enc_strarray(e, s->ppEnabledExtensionNames ? s->ppEnabledExtensionNames : NULL, s->ppEnabledExtensionNames ? (uint32_t)(s->enabledExtensionCount) : 0); + if (s->pEnabledFeatures) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pEnabledFeatures, (size_t)n_ * sizeof(*s->pEnabledFeatures)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDeviceCreateInfo(vkb_enc *e, const VkDeviceCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceCreateInfo(e, s, raw); +} + +void vkb_decfix_VkDeviceCreateInfo(vkb_dec *d, VkDeviceCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkDeviceQueueCreateInfo *a_ = (VkDeviceQueueCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkDeviceQueueCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkDeviceQueueCreateInfo(d, &a_[i_]); + s->pQueueCreateInfos = a_; + } else { + s->pQueueCreateInfos = NULL; + } + s->ppEnabledLayerNames = vkb_dec_strarray(d); + s->ppEnabledExtensionNames = vkb_dec_strarray(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pEnabledFeatures = (const VkPhysicalDeviceFeatures *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkPhysicalDeviceFeatures)); + } else { + s->pEnabledFeatures = NULL; + } +} + +void vkb_dec_VkDeviceCreateInfo(vkb_dec *d, VkDeviceCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceCreateInfo(d, s); +} + +void vkb_encfix_VkDeviceGroupBindSparseInfo(vkb_enc *e, const VkDeviceGroupBindSparseInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkDeviceGroupBindSparseInfo(vkb_enc *e, const VkDeviceGroupBindSparseInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceGroupBindSparseInfo(e, s, raw); +} + +void vkb_decfix_VkDeviceGroupBindSparseInfo(vkb_dec *d, VkDeviceGroupBindSparseInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkDeviceGroupBindSparseInfo(vkb_dec *d, VkDeviceGroupBindSparseInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceGroupBindSparseInfo(d, s); +} + +void vkb_encfix_VkDeviceGroupCommandBufferBeginInfo(vkb_enc *e, const VkDeviceGroupCommandBufferBeginInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkDeviceGroupCommandBufferBeginInfo(vkb_enc *e, const VkDeviceGroupCommandBufferBeginInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceGroupCommandBufferBeginInfo(e, s, raw); +} + +void vkb_decfix_VkDeviceGroupCommandBufferBeginInfo(vkb_dec *d, VkDeviceGroupCommandBufferBeginInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkDeviceGroupCommandBufferBeginInfo(vkb_dec *d, VkDeviceGroupCommandBufferBeginInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceGroupCommandBufferBeginInfo(d, s); +} + +void vkb_encfix_VkDeviceGroupDeviceCreateInfo(vkb_enc *e, const VkDeviceGroupDeviceCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pPhysicalDevices) { + uint32_t n_ = (uint32_t)(s->physicalDeviceCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_u64(e, vkb_remote((const void *)s->pPhysicalDevices[i_])); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDeviceGroupDeviceCreateInfo(vkb_enc *e, const VkDeviceGroupDeviceCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceGroupDeviceCreateInfo(e, s, raw); +} + +void vkb_decfix_VkDeviceGroupDeviceCreateInfo(vkb_dec *d, VkDeviceGroupDeviceCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPhysicalDevice *a_ = (VkPhysicalDevice *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPhysicalDevice)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) a_[i_] = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(d); + s->pPhysicalDevices = a_; + } else { + s->pPhysicalDevices = NULL; + } +} + +void vkb_dec_VkDeviceGroupDeviceCreateInfo(vkb_dec *d, VkDeviceGroupDeviceCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceGroupDeviceCreateInfo(d, s); +} + +void vkb_encfix_VkDeviceGroupRenderPassBeginInfo(vkb_enc *e, const VkDeviceGroupRenderPassBeginInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pDeviceRenderAreas) { + uint32_t n_ = (uint32_t)(s->deviceRenderAreaCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDeviceRenderAreas, (size_t)n_ * sizeof(*s->pDeviceRenderAreas)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDeviceGroupRenderPassBeginInfo(vkb_enc *e, const VkDeviceGroupRenderPassBeginInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceGroupRenderPassBeginInfo(e, s, raw); +} + +void vkb_decfix_VkDeviceGroupRenderPassBeginInfo(vkb_dec *d, VkDeviceGroupRenderPassBeginInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDeviceRenderAreas = (const VkRect2D *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkRect2D)); + } else { + s->pDeviceRenderAreas = NULL; + } +} + +void vkb_dec_VkDeviceGroupRenderPassBeginInfo(vkb_dec *d, VkDeviceGroupRenderPassBeginInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceGroupRenderPassBeginInfo(d, s); +} + +void vkb_encfix_VkDeviceGroupSubmitInfo(vkb_enc *e, const VkDeviceGroupSubmitInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pWaitSemaphoreDeviceIndices) { + uint32_t n_ = (uint32_t)(s->waitSemaphoreCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pWaitSemaphoreDeviceIndices, (size_t)n_ * sizeof(*s->pWaitSemaphoreDeviceIndices)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pCommandBufferDeviceMasks) { + uint32_t n_ = (uint32_t)(s->commandBufferCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pCommandBufferDeviceMasks, (size_t)n_ * sizeof(*s->pCommandBufferDeviceMasks)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pSignalSemaphoreDeviceIndices) { + uint32_t n_ = (uint32_t)(s->signalSemaphoreCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pSignalSemaphoreDeviceIndices, (size_t)n_ * sizeof(*s->pSignalSemaphoreDeviceIndices)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDeviceGroupSubmitInfo(vkb_enc *e, const VkDeviceGroupSubmitInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceGroupSubmitInfo(e, s, raw); +} + +void vkb_decfix_VkDeviceGroupSubmitInfo(vkb_dec *d, VkDeviceGroupSubmitInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pWaitSemaphoreDeviceIndices = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pWaitSemaphoreDeviceIndices = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pCommandBufferDeviceMasks = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pCommandBufferDeviceMasks = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pSignalSemaphoreDeviceIndices = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pSignalSemaphoreDeviceIndices = NULL; + } +} + +void vkb_dec_VkDeviceGroupSubmitInfo(vkb_dec *d, VkDeviceGroupSubmitInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceGroupSubmitInfo(d, s); +} + +void vkb_encfix_VkDeviceImageMemoryRequirements(vkb_enc *e, const VkDeviceImageMemoryRequirements *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pCreateInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageCreateInfo(e, &s->pCreateInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDeviceImageMemoryRequirements(vkb_enc *e, const VkDeviceImageMemoryRequirements *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceImageMemoryRequirements(e, s, raw); +} + +void vkb_decfix_VkDeviceImageMemoryRequirements(vkb_dec *d, VkDeviceImageMemoryRequirements *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageCreateInfo *a_ = (VkImageCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageCreateInfo(d, &a_[i_]); + s->pCreateInfo = a_; + } else { + s->pCreateInfo = NULL; + } +} + +void vkb_dec_VkDeviceImageMemoryRequirements(vkb_dec *d, VkDeviceImageMemoryRequirements *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceImageMemoryRequirements(d, s); +} + +void vkb_encfix_VkDeviceMemoryOpaqueCaptureAddressInfo(vkb_enc *e, const VkDeviceMemoryOpaqueCaptureAddressInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkDeviceMemoryOpaqueCaptureAddressInfo(vkb_enc *e, const VkDeviceMemoryOpaqueCaptureAddressInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceMemoryOpaqueCaptureAddressInfo(e, s, raw); +} + +void vkb_decfix_VkDeviceMemoryOpaqueCaptureAddressInfo(vkb_dec *d, VkDeviceMemoryOpaqueCaptureAddressInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkDeviceMemoryOpaqueCaptureAddressInfo(vkb_dec *d, VkDeviceMemoryOpaqueCaptureAddressInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceMemoryOpaqueCaptureAddressInfo(d, s); +} + +void vkb_encfix_VkDevicePrivateDataCreateInfo(vkb_enc *e, const VkDevicePrivateDataCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkDevicePrivateDataCreateInfo(vkb_enc *e, const VkDevicePrivateDataCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDevicePrivateDataCreateInfo(e, s, raw); +} + +void vkb_decfix_VkDevicePrivateDataCreateInfo(vkb_dec *d, VkDevicePrivateDataCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkDevicePrivateDataCreateInfo(vkb_dec *d, VkDevicePrivateDataCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDevicePrivateDataCreateInfo(d, s); +} + +void vkb_encfix_VkDeviceQueueCreateInfo(vkb_enc *e, const VkDeviceQueueCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pQueuePriorities) { + uint32_t n_ = (uint32_t)(s->queueCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pQueuePriorities, (size_t)n_ * sizeof(*s->pQueuePriorities)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDeviceQueueCreateInfo(vkb_enc *e, const VkDeviceQueueCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceQueueCreateInfo(e, s, raw); +} + +void vkb_decfix_VkDeviceQueueCreateInfo(vkb_dec *d, VkDeviceQueueCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pQueuePriorities = (const float *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(float)); + } else { + s->pQueuePriorities = NULL; + } +} + +void vkb_dec_VkDeviceQueueCreateInfo(vkb_dec *d, VkDeviceQueueCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceQueueCreateInfo(d, s); +} + +void vkb_encfix_VkDeviceQueueGlobalPriorityCreateInfoKHR(vkb_enc *e, const VkDeviceQueueGlobalPriorityCreateInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkDeviceQueueGlobalPriorityCreateInfoKHR(vkb_enc *e, const VkDeviceQueueGlobalPriorityCreateInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceQueueGlobalPriorityCreateInfoKHR(e, s, raw); +} + +void vkb_decfix_VkDeviceQueueGlobalPriorityCreateInfoKHR(vkb_dec *d, VkDeviceQueueGlobalPriorityCreateInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkDeviceQueueGlobalPriorityCreateInfoKHR(vkb_dec *d, VkDeviceQueueGlobalPriorityCreateInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceQueueGlobalPriorityCreateInfoKHR(d, s); +} + +void vkb_encfix_VkDeviceQueueInfo2(vkb_enc *e, const VkDeviceQueueInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkDeviceQueueInfo2(vkb_enc *e, const VkDeviceQueueInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDeviceQueueInfo2(e, s, raw); +} + +void vkb_decfix_VkDeviceQueueInfo2(vkb_dec *d, VkDeviceQueueInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkDeviceQueueInfo2(vkb_dec *d, VkDeviceQueueInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDeviceQueueInfo2(d, s); +} + +void vkb_encfix_VkDrmFormatModifierPropertiesList2EXT(vkb_enc *e, const VkDrmFormatModifierPropertiesList2EXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pDrmFormatModifierProperties) { + uint32_t n_ = (uint32_t)(s->drmFormatModifierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDrmFormatModifierProperties, (size_t)n_ * sizeof(*s->pDrmFormatModifierProperties)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDrmFormatModifierPropertiesList2EXT(vkb_enc *e, const VkDrmFormatModifierPropertiesList2EXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDrmFormatModifierPropertiesList2EXT(e, s, raw); +} + +void vkb_decfix_VkDrmFormatModifierPropertiesList2EXT(vkb_dec *d, VkDrmFormatModifierPropertiesList2EXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDrmFormatModifierProperties = (VkDrmFormatModifierProperties2EXT *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDrmFormatModifierProperties2EXT)); + } else { + s->pDrmFormatModifierProperties = NULL; + } +} + +void vkb_dec_VkDrmFormatModifierPropertiesList2EXT(vkb_dec *d, VkDrmFormatModifierPropertiesList2EXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDrmFormatModifierPropertiesList2EXT(d, s); +} + +void vkb_encfix_VkDrmFormatModifierPropertiesListEXT(vkb_enc *e, const VkDrmFormatModifierPropertiesListEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pDrmFormatModifierProperties) { + uint32_t n_ = (uint32_t)(s->drmFormatModifierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDrmFormatModifierProperties, (size_t)n_ * sizeof(*s->pDrmFormatModifierProperties)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkDrmFormatModifierPropertiesListEXT(vkb_enc *e, const VkDrmFormatModifierPropertiesListEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkDrmFormatModifierPropertiesListEXT(e, s, raw); +} + +void vkb_decfix_VkDrmFormatModifierPropertiesListEXT(vkb_dec *d, VkDrmFormatModifierPropertiesListEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDrmFormatModifierProperties = (VkDrmFormatModifierPropertiesEXT *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDrmFormatModifierPropertiesEXT)); + } else { + s->pDrmFormatModifierProperties = NULL; + } +} + +void vkb_dec_VkDrmFormatModifierPropertiesListEXT(vkb_dec *d, VkDrmFormatModifierPropertiesListEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkDrmFormatModifierPropertiesListEXT(d, s); +} + +void vkb_encfix_VkEventCreateInfo(vkb_enc *e, const VkEventCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkEventCreateInfo(vkb_enc *e, const VkEventCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkEventCreateInfo(e, s, raw); +} + +void vkb_decfix_VkEventCreateInfo(vkb_dec *d, VkEventCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkEventCreateInfo(vkb_dec *d, VkEventCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkEventCreateInfo(d, s); +} + +void vkb_encfix_VkExportFenceCreateInfo(vkb_enc *e, const VkExportFenceCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkExportFenceCreateInfo(vkb_enc *e, const VkExportFenceCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkExportFenceCreateInfo(e, s, raw); +} + +void vkb_decfix_VkExportFenceCreateInfo(vkb_dec *d, VkExportFenceCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkExportFenceCreateInfo(vkb_dec *d, VkExportFenceCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkExportFenceCreateInfo(d, s); +} + +void vkb_encfix_VkExportMemoryAllocateInfo(vkb_enc *e, const VkExportMemoryAllocateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkExportMemoryAllocateInfo(vkb_enc *e, const VkExportMemoryAllocateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkExportMemoryAllocateInfo(e, s, raw); +} + +void vkb_decfix_VkExportMemoryAllocateInfo(vkb_dec *d, VkExportMemoryAllocateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkExportMemoryAllocateInfo(vkb_dec *d, VkExportMemoryAllocateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkExportMemoryAllocateInfo(d, s); +} + +void vkb_encfix_VkExportSemaphoreCreateInfo(vkb_enc *e, const VkExportSemaphoreCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkExportSemaphoreCreateInfo(vkb_enc *e, const VkExportSemaphoreCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkExportSemaphoreCreateInfo(e, s, raw); +} + +void vkb_decfix_VkExportSemaphoreCreateInfo(vkb_dec *d, VkExportSemaphoreCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkExportSemaphoreCreateInfo(vkb_dec *d, VkExportSemaphoreCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkExportSemaphoreCreateInfo(d, s); +} + +void vkb_encfix_VkExternalBufferProperties(vkb_enc *e, const VkExternalBufferProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkExternalBufferProperties(vkb_enc *e, const VkExternalBufferProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkExternalBufferProperties(e, s, raw); +} + +void vkb_decfix_VkExternalBufferProperties(vkb_dec *d, VkExternalBufferProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkExternalBufferProperties(vkb_dec *d, VkExternalBufferProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkExternalBufferProperties(d, s); +} + +void vkb_encfix_VkExternalFenceProperties(vkb_enc *e, const VkExternalFenceProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkExternalFenceProperties(vkb_enc *e, const VkExternalFenceProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkExternalFenceProperties(e, s, raw); +} + +void vkb_decfix_VkExternalFenceProperties(vkb_dec *d, VkExternalFenceProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkExternalFenceProperties(vkb_dec *d, VkExternalFenceProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkExternalFenceProperties(d, s); +} + +void vkb_encfix_VkExternalImageFormatProperties(vkb_enc *e, const VkExternalImageFormatProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkExternalImageFormatProperties(vkb_enc *e, const VkExternalImageFormatProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkExternalImageFormatProperties(e, s, raw); +} + +void vkb_decfix_VkExternalImageFormatProperties(vkb_dec *d, VkExternalImageFormatProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkExternalImageFormatProperties(vkb_dec *d, VkExternalImageFormatProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkExternalImageFormatProperties(d, s); +} + +void vkb_encfix_VkExternalMemoryBufferCreateInfo(vkb_enc *e, const VkExternalMemoryBufferCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkExternalMemoryBufferCreateInfo(vkb_enc *e, const VkExternalMemoryBufferCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkExternalMemoryBufferCreateInfo(e, s, raw); +} + +void vkb_decfix_VkExternalMemoryBufferCreateInfo(vkb_dec *d, VkExternalMemoryBufferCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkExternalMemoryBufferCreateInfo(vkb_dec *d, VkExternalMemoryBufferCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkExternalMemoryBufferCreateInfo(d, s); +} + +void vkb_encfix_VkExternalMemoryImageCreateInfo(vkb_enc *e, const VkExternalMemoryImageCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkExternalMemoryImageCreateInfo(vkb_enc *e, const VkExternalMemoryImageCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkExternalMemoryImageCreateInfo(e, s, raw); +} + +void vkb_decfix_VkExternalMemoryImageCreateInfo(vkb_dec *d, VkExternalMemoryImageCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkExternalMemoryImageCreateInfo(vkb_dec *d, VkExternalMemoryImageCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkExternalMemoryImageCreateInfo(d, s); +} + +void vkb_encfix_VkExternalSemaphoreProperties(vkb_enc *e, const VkExternalSemaphoreProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkExternalSemaphoreProperties(vkb_enc *e, const VkExternalSemaphoreProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkExternalSemaphoreProperties(e, s, raw); +} + +void vkb_decfix_VkExternalSemaphoreProperties(vkb_dec *d, VkExternalSemaphoreProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkExternalSemaphoreProperties(vkb_dec *d, VkExternalSemaphoreProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkExternalSemaphoreProperties(d, s); +} + +void vkb_encfix_VkFenceCreateInfo(vkb_enc *e, const VkFenceCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkFenceCreateInfo(vkb_enc *e, const VkFenceCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkFenceCreateInfo(e, s, raw); +} + +void vkb_decfix_VkFenceCreateInfo(vkb_dec *d, VkFenceCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkFenceCreateInfo(vkb_dec *d, VkFenceCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkFenceCreateInfo(d, s); +} + +void vkb_encfix_VkFenceGetFdInfoKHR(vkb_enc *e, const VkFenceGetFdInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkFenceGetFdInfoKHR(vkb_enc *e, const VkFenceGetFdInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkFenceGetFdInfoKHR(e, s, raw); +} + +void vkb_decfix_VkFenceGetFdInfoKHR(vkb_dec *d, VkFenceGetFdInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkFenceGetFdInfoKHR(vkb_dec *d, VkFenceGetFdInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkFenceGetFdInfoKHR(d, s); +} + +void vkb_encfix_VkFilterCubicImageViewImageFormatPropertiesEXT(vkb_enc *e, const VkFilterCubicImageViewImageFormatPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkFilterCubicImageViewImageFormatPropertiesEXT(vkb_enc *e, const VkFilterCubicImageViewImageFormatPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkFilterCubicImageViewImageFormatPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkFilterCubicImageViewImageFormatPropertiesEXT(vkb_dec *d, VkFilterCubicImageViewImageFormatPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkFilterCubicImageViewImageFormatPropertiesEXT(vkb_dec *d, VkFilterCubicImageViewImageFormatPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkFilterCubicImageViewImageFormatPropertiesEXT(d, s); +} + +void vkb_encfix_VkFormatProperties2(vkb_enc *e, const VkFormatProperties2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkFormatProperties2(vkb_enc *e, const VkFormatProperties2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkFormatProperties2(e, s, raw); +} + +void vkb_decfix_VkFormatProperties2(vkb_dec *d, VkFormatProperties2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkFormatProperties2(vkb_dec *d, VkFormatProperties2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkFormatProperties2(d, s); +} + +void vkb_encfix_VkFormatProperties3(vkb_enc *e, const VkFormatProperties3 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkFormatProperties3(vkb_enc *e, const VkFormatProperties3 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkFormatProperties3(e, s, raw); +} + +void vkb_decfix_VkFormatProperties3(vkb_dec *d, VkFormatProperties3 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkFormatProperties3(vkb_dec *d, VkFormatProperties3 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkFormatProperties3(d, s); +} + +void vkb_encfix_VkFragmentShadingRateAttachmentInfoKHR(vkb_enc *e, const VkFragmentShadingRateAttachmentInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pFragmentShadingRateAttachment) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkAttachmentReference2(e, &s->pFragmentShadingRateAttachment[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkFragmentShadingRateAttachmentInfoKHR(vkb_enc *e, const VkFragmentShadingRateAttachmentInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkFragmentShadingRateAttachmentInfoKHR(e, s, raw); +} + +void vkb_decfix_VkFragmentShadingRateAttachmentInfoKHR(vkb_dec *d, VkFragmentShadingRateAttachmentInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkAttachmentReference2 *a_ = (VkAttachmentReference2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkAttachmentReference2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkAttachmentReference2(d, &a_[i_]); + s->pFragmentShadingRateAttachment = a_; + } else { + s->pFragmentShadingRateAttachment = NULL; + } +} + +void vkb_dec_VkFragmentShadingRateAttachmentInfoKHR(vkb_dec *d, VkFragmentShadingRateAttachmentInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkFragmentShadingRateAttachmentInfoKHR(d, s); +} + +void vkb_encfix_VkFramebufferAttachmentImageInfo(vkb_enc *e, const VkFramebufferAttachmentImageInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pViewFormats) { + uint32_t n_ = (uint32_t)(s->viewFormatCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pViewFormats, (size_t)n_ * sizeof(*s->pViewFormats)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkFramebufferAttachmentImageInfo(vkb_enc *e, const VkFramebufferAttachmentImageInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkFramebufferAttachmentImageInfo(e, s, raw); +} + +void vkb_decfix_VkFramebufferAttachmentImageInfo(vkb_dec *d, VkFramebufferAttachmentImageInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pViewFormats = (const VkFormat *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkFormat)); + } else { + s->pViewFormats = NULL; + } +} + +void vkb_dec_VkFramebufferAttachmentImageInfo(vkb_dec *d, VkFramebufferAttachmentImageInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkFramebufferAttachmentImageInfo(d, s); +} + +void vkb_encfix_VkFramebufferAttachmentsCreateInfo(vkb_enc *e, const VkFramebufferAttachmentsCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pAttachmentImageInfos) { + uint32_t n_ = (uint32_t)(s->attachmentImageInfoCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkFramebufferAttachmentImageInfo(e, &s->pAttachmentImageInfos[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkFramebufferAttachmentsCreateInfo(vkb_enc *e, const VkFramebufferAttachmentsCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkFramebufferAttachmentsCreateInfo(e, s, raw); +} + +void vkb_decfix_VkFramebufferAttachmentsCreateInfo(vkb_dec *d, VkFramebufferAttachmentsCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkFramebufferAttachmentImageInfo *a_ = (VkFramebufferAttachmentImageInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkFramebufferAttachmentImageInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkFramebufferAttachmentImageInfo(d, &a_[i_]); + s->pAttachmentImageInfos = a_; + } else { + s->pAttachmentImageInfos = NULL; + } +} + +void vkb_dec_VkFramebufferAttachmentsCreateInfo(vkb_dec *d, VkFramebufferAttachmentsCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkFramebufferAttachmentsCreateInfo(d, s); +} + +void vkb_encfix_VkFramebufferCreateInfo(vkb_enc *e, const VkFramebufferCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pAttachments && (!(s->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT))) { + uint32_t n_ = (uint32_t)(s->attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pAttachments, (size_t)n_ * sizeof(*s->pAttachments)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkFramebufferCreateInfo(vkb_enc *e, const VkFramebufferCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkFramebufferCreateInfo(e, s, raw); +} + +void vkb_decfix_VkFramebufferCreateInfo(vkb_dec *d, VkFramebufferCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pAttachments = (const VkImageView *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkImageView)); + } else { + s->pAttachments = NULL; + } +} + +void vkb_dec_VkFramebufferCreateInfo(vkb_dec *d, VkFramebufferCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkFramebufferCreateInfo(d, s); +} + +void vkb_encfix_VkGraphicsPipelineCreateInfo(vkb_enc *e, const VkGraphicsPipelineCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pStages) { + uint32_t n_ = (uint32_t)(s->stageCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineShaderStageCreateInfo(e, &s->pStages[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pVertexInputState) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineVertexInputStateCreateInfo(e, &s->pVertexInputState[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pInputAssemblyState) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineInputAssemblyStateCreateInfo(e, &s->pInputAssemblyState[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pTessellationState && (vkb_gp_has_tess(s))) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineTessellationStateCreateInfo(e, &s->pTessellationState[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pViewportState) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineViewportStateCreateInfo(e, &s->pViewportState[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pRasterizationState) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineRasterizationStateCreateInfo(e, &s->pRasterizationState[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pMultisampleState) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineMultisampleStateCreateInfo(e, &s->pMultisampleState[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pDepthStencilState) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineDepthStencilStateCreateInfo(e, &s->pDepthStencilState[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pColorBlendState) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineColorBlendStateCreateInfo(e, &s->pColorBlendState[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pDynamicState) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkPipelineDynamicStateCreateInfo(e, &s->pDynamicState[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkGraphicsPipelineCreateInfo(vkb_enc *e, const VkGraphicsPipelineCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkGraphicsPipelineCreateInfo(e, s, raw); +} + +void vkb_decfix_VkGraphicsPipelineCreateInfo(vkb_dec *d, VkGraphicsPipelineCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineShaderStageCreateInfo *a_ = (VkPipelineShaderStageCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineShaderStageCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineShaderStageCreateInfo(d, &a_[i_]); + s->pStages = a_; + } else { + s->pStages = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineVertexInputStateCreateInfo *a_ = (VkPipelineVertexInputStateCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineVertexInputStateCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineVertexInputStateCreateInfo(d, &a_[i_]); + s->pVertexInputState = a_; + } else { + s->pVertexInputState = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineInputAssemblyStateCreateInfo *a_ = (VkPipelineInputAssemblyStateCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineInputAssemblyStateCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineInputAssemblyStateCreateInfo(d, &a_[i_]); + s->pInputAssemblyState = a_; + } else { + s->pInputAssemblyState = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineTessellationStateCreateInfo *a_ = (VkPipelineTessellationStateCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineTessellationStateCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineTessellationStateCreateInfo(d, &a_[i_]); + s->pTessellationState = a_; + } else { + s->pTessellationState = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineViewportStateCreateInfo *a_ = (VkPipelineViewportStateCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineViewportStateCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineViewportStateCreateInfo(d, &a_[i_]); + s->pViewportState = a_; + } else { + s->pViewportState = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineRasterizationStateCreateInfo *a_ = (VkPipelineRasterizationStateCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineRasterizationStateCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineRasterizationStateCreateInfo(d, &a_[i_]); + s->pRasterizationState = a_; + } else { + s->pRasterizationState = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineMultisampleStateCreateInfo *a_ = (VkPipelineMultisampleStateCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineMultisampleStateCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineMultisampleStateCreateInfo(d, &a_[i_]); + s->pMultisampleState = a_; + } else { + s->pMultisampleState = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineDepthStencilStateCreateInfo *a_ = (VkPipelineDepthStencilStateCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineDepthStencilStateCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineDepthStencilStateCreateInfo(d, &a_[i_]); + s->pDepthStencilState = a_; + } else { + s->pDepthStencilState = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineColorBlendStateCreateInfo *a_ = (VkPipelineColorBlendStateCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineColorBlendStateCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineColorBlendStateCreateInfo(d, &a_[i_]); + s->pColorBlendState = a_; + } else { + s->pColorBlendState = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkPipelineDynamicStateCreateInfo *a_ = (VkPipelineDynamicStateCreateInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkPipelineDynamicStateCreateInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkPipelineDynamicStateCreateInfo(d, &a_[i_]); + s->pDynamicState = a_; + } else { + s->pDynamicState = NULL; + } +} + +void vkb_dec_VkGraphicsPipelineCreateInfo(vkb_dec *d, VkGraphicsPipelineCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkGraphicsPipelineCreateInfo(d, s); +} + +void vkb_encfix_VkGraphicsPipelineLibraryCreateInfoEXT(vkb_enc *e, const VkGraphicsPipelineLibraryCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkGraphicsPipelineLibraryCreateInfoEXT(vkb_enc *e, const VkGraphicsPipelineLibraryCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkGraphicsPipelineLibraryCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkGraphicsPipelineLibraryCreateInfoEXT(vkb_dec *d, VkGraphicsPipelineLibraryCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkGraphicsPipelineLibraryCreateInfoEXT(vkb_dec *d, VkGraphicsPipelineLibraryCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkGraphicsPipelineLibraryCreateInfoEXT(d, s); +} + +void vkb_encfix_VkImageBlit2(vkb_enc *e, const VkImageBlit2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageBlit2(vkb_enc *e, const VkImageBlit2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageBlit2(e, s, raw); +} + +void vkb_decfix_VkImageBlit2(vkb_dec *d, VkImageBlit2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageBlit2(vkb_dec *d, VkImageBlit2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageBlit2(d, s); +} + +void vkb_encfix_VkImageCompressionControlEXT(vkb_enc *e, const VkImageCompressionControlEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pFixedRateFlags && (s->flags == VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT)) { + uint32_t n_ = (uint32_t)(s->compressionControlPlaneCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pFixedRateFlags, (size_t)n_ * sizeof(*s->pFixedRateFlags)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkImageCompressionControlEXT(vkb_enc *e, const VkImageCompressionControlEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageCompressionControlEXT(e, s, raw); +} + +void vkb_decfix_VkImageCompressionControlEXT(vkb_dec *d, VkImageCompressionControlEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkImageCompressionFixedRateFlagsEXT)); + } else { + s->pFixedRateFlags = NULL; + } +} + +void vkb_dec_VkImageCompressionControlEXT(vkb_dec *d, VkImageCompressionControlEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageCompressionControlEXT(d, s); +} + +void vkb_encfix_VkImageCompressionPropertiesEXT(vkb_enc *e, const VkImageCompressionPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageCompressionPropertiesEXT(vkb_enc *e, const VkImageCompressionPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageCompressionPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkImageCompressionPropertiesEXT(vkb_dec *d, VkImageCompressionPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageCompressionPropertiesEXT(vkb_dec *d, VkImageCompressionPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageCompressionPropertiesEXT(d, s); +} + +void vkb_encfix_VkImageCopy2(vkb_enc *e, const VkImageCopy2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageCopy2(vkb_enc *e, const VkImageCopy2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageCopy2(e, s, raw); +} + +void vkb_decfix_VkImageCopy2(vkb_dec *d, VkImageCopy2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageCopy2(vkb_dec *d, VkImageCopy2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageCopy2(d, s); +} + +void vkb_encfix_VkImageCreateInfo(vkb_enc *e, const VkImageCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pQueueFamilyIndices && (s->sharingMode == VK_SHARING_MODE_CONCURRENT)) { + uint32_t n_ = (uint32_t)(s->queueFamilyIndexCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pQueueFamilyIndices, (size_t)n_ * sizeof(*s->pQueueFamilyIndices)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkImageCreateInfo(vkb_enc *e, const VkImageCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageCreateInfo(e, s, raw); +} + +void vkb_decfix_VkImageCreateInfo(vkb_dec *d, VkImageCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pQueueFamilyIndices = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pQueueFamilyIndices = NULL; + } +} + +void vkb_dec_VkImageCreateInfo(vkb_dec *d, VkImageCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageCreateInfo(d, s); +} + +void vkb_encfix_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkb_enc *e, const VkImageDrmFormatModifierExplicitCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pPlaneLayouts) { + uint32_t n_ = (uint32_t)(s->drmFormatModifierPlaneCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pPlaneLayouts, (size_t)n_ * sizeof(*s->pPlaneLayouts)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkb_enc *e, const VkImageDrmFormatModifierExplicitCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageDrmFormatModifierExplicitCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkb_dec *d, VkImageDrmFormatModifierExplicitCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pPlaneLayouts = (const VkSubresourceLayout *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSubresourceLayout)); + } else { + s->pPlaneLayouts = NULL; + } +} + +void vkb_dec_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkb_dec *d, VkImageDrmFormatModifierExplicitCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageDrmFormatModifierExplicitCreateInfoEXT(d, s); +} + +void vkb_encfix_VkImageDrmFormatModifierListCreateInfoEXT(vkb_enc *e, const VkImageDrmFormatModifierListCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pDrmFormatModifiers) { + uint32_t n_ = (uint32_t)(s->drmFormatModifierCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDrmFormatModifiers, (size_t)n_ * sizeof(*s->pDrmFormatModifiers)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkImageDrmFormatModifierListCreateInfoEXT(vkb_enc *e, const VkImageDrmFormatModifierListCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageDrmFormatModifierListCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkImageDrmFormatModifierListCreateInfoEXT(vkb_dec *d, VkImageDrmFormatModifierListCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDrmFormatModifiers = (const uint64_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint64_t)); + } else { + s->pDrmFormatModifiers = NULL; + } +} + +void vkb_dec_VkImageDrmFormatModifierListCreateInfoEXT(vkb_dec *d, VkImageDrmFormatModifierListCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageDrmFormatModifierListCreateInfoEXT(d, s); +} + +void vkb_encfix_VkImageDrmFormatModifierPropertiesEXT(vkb_enc *e, const VkImageDrmFormatModifierPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageDrmFormatModifierPropertiesEXT(vkb_enc *e, const VkImageDrmFormatModifierPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageDrmFormatModifierPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkImageDrmFormatModifierPropertiesEXT(vkb_dec *d, VkImageDrmFormatModifierPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageDrmFormatModifierPropertiesEXT(vkb_dec *d, VkImageDrmFormatModifierPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageDrmFormatModifierPropertiesEXT(d, s); +} + +void vkb_encfix_VkImageFormatListCreateInfo(vkb_enc *e, const VkImageFormatListCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pViewFormats) { + uint32_t n_ = (uint32_t)(s->viewFormatCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pViewFormats, (size_t)n_ * sizeof(*s->pViewFormats)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkImageFormatListCreateInfo(vkb_enc *e, const VkImageFormatListCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageFormatListCreateInfo(e, s, raw); +} + +void vkb_decfix_VkImageFormatListCreateInfo(vkb_dec *d, VkImageFormatListCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pViewFormats = (const VkFormat *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkFormat)); + } else { + s->pViewFormats = NULL; + } +} + +void vkb_dec_VkImageFormatListCreateInfo(vkb_dec *d, VkImageFormatListCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageFormatListCreateInfo(d, s); +} + +void vkb_encfix_VkImageFormatProperties2(vkb_enc *e, const VkImageFormatProperties2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageFormatProperties2(vkb_enc *e, const VkImageFormatProperties2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageFormatProperties2(e, s, raw); +} + +void vkb_decfix_VkImageFormatProperties2(vkb_dec *d, VkImageFormatProperties2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageFormatProperties2(vkb_dec *d, VkImageFormatProperties2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageFormatProperties2(d, s); +} + +void vkb_encfix_VkImageMemoryBarrier(vkb_enc *e, const VkImageMemoryBarrier *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageMemoryBarrier(vkb_enc *e, const VkImageMemoryBarrier *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageMemoryBarrier(e, s, raw); +} + +void vkb_decfix_VkImageMemoryBarrier(vkb_dec *d, VkImageMemoryBarrier *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageMemoryBarrier(vkb_dec *d, VkImageMemoryBarrier *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageMemoryBarrier(d, s); +} + +void vkb_encfix_VkImageMemoryBarrier2(vkb_enc *e, const VkImageMemoryBarrier2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageMemoryBarrier2(vkb_enc *e, const VkImageMemoryBarrier2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageMemoryBarrier2(e, s, raw); +} + +void vkb_decfix_VkImageMemoryBarrier2(vkb_dec *d, VkImageMemoryBarrier2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageMemoryBarrier2(vkb_dec *d, VkImageMemoryBarrier2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageMemoryBarrier2(d, s); +} + +void vkb_encfix_VkImageMemoryRequirementsInfo2(vkb_enc *e, const VkImageMemoryRequirementsInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageMemoryRequirementsInfo2(vkb_enc *e, const VkImageMemoryRequirementsInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageMemoryRequirementsInfo2(e, s, raw); +} + +void vkb_decfix_VkImageMemoryRequirementsInfo2(vkb_dec *d, VkImageMemoryRequirementsInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageMemoryRequirementsInfo2(vkb_dec *d, VkImageMemoryRequirementsInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageMemoryRequirementsInfo2(d, s); +} + +void vkb_encfix_VkImagePlaneMemoryRequirementsInfo(vkb_enc *e, const VkImagePlaneMemoryRequirementsInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImagePlaneMemoryRequirementsInfo(vkb_enc *e, const VkImagePlaneMemoryRequirementsInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImagePlaneMemoryRequirementsInfo(e, s, raw); +} + +void vkb_decfix_VkImagePlaneMemoryRequirementsInfo(vkb_dec *d, VkImagePlaneMemoryRequirementsInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImagePlaneMemoryRequirementsInfo(vkb_dec *d, VkImagePlaneMemoryRequirementsInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImagePlaneMemoryRequirementsInfo(d, s); +} + +void vkb_encfix_VkImageResolve2(vkb_enc *e, const VkImageResolve2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageResolve2(vkb_enc *e, const VkImageResolve2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageResolve2(e, s, raw); +} + +void vkb_decfix_VkImageResolve2(vkb_dec *d, VkImageResolve2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageResolve2(vkb_dec *d, VkImageResolve2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageResolve2(d, s); +} + +void vkb_encfix_VkImageSparseMemoryRequirementsInfo2(vkb_enc *e, const VkImageSparseMemoryRequirementsInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageSparseMemoryRequirementsInfo2(vkb_enc *e, const VkImageSparseMemoryRequirementsInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageSparseMemoryRequirementsInfo2(e, s, raw); +} + +void vkb_decfix_VkImageSparseMemoryRequirementsInfo2(vkb_dec *d, VkImageSparseMemoryRequirementsInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageSparseMemoryRequirementsInfo2(vkb_dec *d, VkImageSparseMemoryRequirementsInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageSparseMemoryRequirementsInfo2(d, s); +} + +void vkb_encfix_VkImageStencilUsageCreateInfo(vkb_enc *e, const VkImageStencilUsageCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageStencilUsageCreateInfo(vkb_enc *e, const VkImageStencilUsageCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageStencilUsageCreateInfo(e, s, raw); +} + +void vkb_decfix_VkImageStencilUsageCreateInfo(vkb_dec *d, VkImageStencilUsageCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageStencilUsageCreateInfo(vkb_dec *d, VkImageStencilUsageCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageStencilUsageCreateInfo(d, s); +} + +void vkb_encfix_VkImageSubresource2EXT(vkb_enc *e, const VkImageSubresource2EXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageSubresource2EXT(vkb_enc *e, const VkImageSubresource2EXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageSubresource2EXT(e, s, raw); +} + +void vkb_decfix_VkImageSubresource2EXT(vkb_dec *d, VkImageSubresource2EXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageSubresource2EXT(vkb_dec *d, VkImageSubresource2EXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageSubresource2EXT(d, s); +} + +void vkb_encfix_VkImageSwapchainCreateInfoKHR(vkb_enc *e, const VkImageSwapchainCreateInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageSwapchainCreateInfoKHR(vkb_enc *e, const VkImageSwapchainCreateInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageSwapchainCreateInfoKHR(e, s, raw); +} + +void vkb_decfix_VkImageSwapchainCreateInfoKHR(vkb_dec *d, VkImageSwapchainCreateInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageSwapchainCreateInfoKHR(vkb_dec *d, VkImageSwapchainCreateInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageSwapchainCreateInfoKHR(d, s); +} + +void vkb_encfix_VkImageViewASTCDecodeModeEXT(vkb_enc *e, const VkImageViewASTCDecodeModeEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageViewASTCDecodeModeEXT(vkb_enc *e, const VkImageViewASTCDecodeModeEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageViewASTCDecodeModeEXT(e, s, raw); +} + +void vkb_decfix_VkImageViewASTCDecodeModeEXT(vkb_dec *d, VkImageViewASTCDecodeModeEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageViewASTCDecodeModeEXT(vkb_dec *d, VkImageViewASTCDecodeModeEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageViewASTCDecodeModeEXT(d, s); +} + +void vkb_encfix_VkImageViewCreateInfo(vkb_enc *e, const VkImageViewCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageViewCreateInfo(vkb_enc *e, const VkImageViewCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageViewCreateInfo(e, s, raw); +} + +void vkb_decfix_VkImageViewCreateInfo(vkb_dec *d, VkImageViewCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageViewCreateInfo(vkb_dec *d, VkImageViewCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageViewCreateInfo(d, s); +} + +void vkb_encfix_VkImageViewMinLodCreateInfoEXT(vkb_enc *e, const VkImageViewMinLodCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageViewMinLodCreateInfoEXT(vkb_enc *e, const VkImageViewMinLodCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageViewMinLodCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkImageViewMinLodCreateInfoEXT(vkb_dec *d, VkImageViewMinLodCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageViewMinLodCreateInfoEXT(vkb_dec *d, VkImageViewMinLodCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageViewMinLodCreateInfoEXT(d, s); +} + +void vkb_encfix_VkImageViewSlicedCreateInfoEXT(vkb_enc *e, const VkImageViewSlicedCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageViewSlicedCreateInfoEXT(vkb_enc *e, const VkImageViewSlicedCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageViewSlicedCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkImageViewSlicedCreateInfoEXT(vkb_dec *d, VkImageViewSlicedCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageViewSlicedCreateInfoEXT(vkb_dec *d, VkImageViewSlicedCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageViewSlicedCreateInfoEXT(d, s); +} + +void vkb_encfix_VkImageViewUsageCreateInfo(vkb_enc *e, const VkImageViewUsageCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkImageViewUsageCreateInfo(vkb_enc *e, const VkImageViewUsageCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImageViewUsageCreateInfo(e, s, raw); +} + +void vkb_decfix_VkImageViewUsageCreateInfo(vkb_dec *d, VkImageViewUsageCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkImageViewUsageCreateInfo(vkb_dec *d, VkImageViewUsageCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImageViewUsageCreateInfo(d, s); +} + +void vkb_encfix_VkImportFenceFdInfoKHR(vkb_enc *e, const VkImportFenceFdInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_enc_fd(e, s->fd); +} + +void vkb_enc_VkImportFenceFdInfoKHR(vkb_enc *e, const VkImportFenceFdInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImportFenceFdInfoKHR(e, s, raw); +} + +void vkb_decfix_VkImportFenceFdInfoKHR(vkb_dec *d, VkImportFenceFdInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + s->fd = vkb_dec_fd(d); +} + +void vkb_dec_VkImportFenceFdInfoKHR(vkb_dec *d, VkImportFenceFdInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImportFenceFdInfoKHR(d, s); +} + +void vkb_encfix_VkImportMemoryFdInfoKHR(vkb_enc *e, const VkImportMemoryFdInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_enc_fd(e, s->fd); +} + +void vkb_enc_VkImportMemoryFdInfoKHR(vkb_enc *e, const VkImportMemoryFdInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImportMemoryFdInfoKHR(e, s, raw); +} + +void vkb_decfix_VkImportMemoryFdInfoKHR(vkb_dec *d, VkImportMemoryFdInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + s->fd = vkb_dec_fd(d); +} + +void vkb_dec_VkImportMemoryFdInfoKHR(vkb_dec *d, VkImportMemoryFdInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImportMemoryFdInfoKHR(d, s); +} + +void vkb_encfix_VkImportSemaphoreFdInfoKHR(vkb_enc *e, const VkImportSemaphoreFdInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_enc_fd(e, s->fd); +} + +void vkb_enc_VkImportSemaphoreFdInfoKHR(vkb_enc *e, const VkImportSemaphoreFdInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkImportSemaphoreFdInfoKHR(e, s, raw); +} + +void vkb_decfix_VkImportSemaphoreFdInfoKHR(vkb_dec *d, VkImportSemaphoreFdInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + s->fd = vkb_dec_fd(d); +} + +void vkb_dec_VkImportSemaphoreFdInfoKHR(vkb_dec *d, VkImportSemaphoreFdInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkImportSemaphoreFdInfoKHR(d, s); +} + +void vkb_encfix_VkInstanceCreateInfo(vkb_enc *e, const VkInstanceCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pApplicationInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkApplicationInfo(e, &s->pApplicationInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_strarray(e, s->ppEnabledLayerNames ? s->ppEnabledLayerNames : NULL, s->ppEnabledLayerNames ? (uint32_t)(s->enabledLayerCount) : 0); + vkb_enc_strarray(e, s->ppEnabledExtensionNames ? s->ppEnabledExtensionNames : NULL, s->ppEnabledExtensionNames ? (uint32_t)(s->enabledExtensionCount) : 0); +} + +void vkb_enc_VkInstanceCreateInfo(vkb_enc *e, const VkInstanceCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkInstanceCreateInfo(e, s, raw); +} + +void vkb_decfix_VkInstanceCreateInfo(vkb_dec *d, VkInstanceCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkApplicationInfo *a_ = (VkApplicationInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkApplicationInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkApplicationInfo(d, &a_[i_]); + s->pApplicationInfo = a_; + } else { + s->pApplicationInfo = NULL; + } + s->ppEnabledLayerNames = vkb_dec_strarray(d); + s->ppEnabledExtensionNames = vkb_dec_strarray(d); +} + +void vkb_dec_VkInstanceCreateInfo(vkb_dec *d, VkInstanceCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkInstanceCreateInfo(d, s); +} + +void vkb_encfix_VkMappedMemoryRange(vkb_enc *e, const VkMappedMemoryRange *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMappedMemoryRange(vkb_enc *e, const VkMappedMemoryRange *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMappedMemoryRange(e, s, raw); +} + +void vkb_decfix_VkMappedMemoryRange(vkb_dec *d, VkMappedMemoryRange *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMappedMemoryRange(vkb_dec *d, VkMappedMemoryRange *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMappedMemoryRange(d, s); +} + +void vkb_encfix_VkMemoryAllocateFlagsInfo(vkb_enc *e, const VkMemoryAllocateFlagsInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMemoryAllocateFlagsInfo(vkb_enc *e, const VkMemoryAllocateFlagsInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMemoryAllocateFlagsInfo(e, s, raw); +} + +void vkb_decfix_VkMemoryAllocateFlagsInfo(vkb_dec *d, VkMemoryAllocateFlagsInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMemoryAllocateFlagsInfo(vkb_dec *d, VkMemoryAllocateFlagsInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMemoryAllocateFlagsInfo(d, s); +} + +void vkb_encfix_VkMemoryAllocateInfo(vkb_enc *e, const VkMemoryAllocateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMemoryAllocateInfo(vkb_enc *e, const VkMemoryAllocateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMemoryAllocateInfo(e, s, raw); +} + +void vkb_decfix_VkMemoryAllocateInfo(vkb_dec *d, VkMemoryAllocateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMemoryAllocateInfo(vkb_dec *d, VkMemoryAllocateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMemoryAllocateInfo(d, s); +} + +void vkb_encfix_VkMemoryBarrier(vkb_enc *e, const VkMemoryBarrier *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMemoryBarrier(vkb_enc *e, const VkMemoryBarrier *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMemoryBarrier(e, s, raw); +} + +void vkb_decfix_VkMemoryBarrier(vkb_dec *d, VkMemoryBarrier *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMemoryBarrier(vkb_dec *d, VkMemoryBarrier *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMemoryBarrier(d, s); +} + +void vkb_encfix_VkMemoryBarrier2(vkb_enc *e, const VkMemoryBarrier2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMemoryBarrier2(vkb_enc *e, const VkMemoryBarrier2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMemoryBarrier2(e, s, raw); +} + +void vkb_decfix_VkMemoryBarrier2(vkb_dec *d, VkMemoryBarrier2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMemoryBarrier2(vkb_dec *d, VkMemoryBarrier2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMemoryBarrier2(d, s); +} + +void vkb_encfix_VkMemoryDedicatedAllocateInfo(vkb_enc *e, const VkMemoryDedicatedAllocateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMemoryDedicatedAllocateInfo(vkb_enc *e, const VkMemoryDedicatedAllocateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMemoryDedicatedAllocateInfo(e, s, raw); +} + +void vkb_decfix_VkMemoryDedicatedAllocateInfo(vkb_dec *d, VkMemoryDedicatedAllocateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMemoryDedicatedAllocateInfo(vkb_dec *d, VkMemoryDedicatedAllocateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMemoryDedicatedAllocateInfo(d, s); +} + +void vkb_encfix_VkMemoryDedicatedRequirements(vkb_enc *e, const VkMemoryDedicatedRequirements *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMemoryDedicatedRequirements(vkb_enc *e, const VkMemoryDedicatedRequirements *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMemoryDedicatedRequirements(e, s, raw); +} + +void vkb_decfix_VkMemoryDedicatedRequirements(vkb_dec *d, VkMemoryDedicatedRequirements *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMemoryDedicatedRequirements(vkb_dec *d, VkMemoryDedicatedRequirements *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMemoryDedicatedRequirements(d, s); +} + +void vkb_encfix_VkMemoryFdPropertiesKHR(vkb_enc *e, const VkMemoryFdPropertiesKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMemoryFdPropertiesKHR(vkb_enc *e, const VkMemoryFdPropertiesKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMemoryFdPropertiesKHR(e, s, raw); +} + +void vkb_decfix_VkMemoryFdPropertiesKHR(vkb_dec *d, VkMemoryFdPropertiesKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMemoryFdPropertiesKHR(vkb_dec *d, VkMemoryFdPropertiesKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMemoryFdPropertiesKHR(d, s); +} + +void vkb_encfix_VkMemoryGetFdInfoKHR(vkb_enc *e, const VkMemoryGetFdInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMemoryGetFdInfoKHR(vkb_enc *e, const VkMemoryGetFdInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMemoryGetFdInfoKHR(e, s, raw); +} + +void vkb_decfix_VkMemoryGetFdInfoKHR(vkb_dec *d, VkMemoryGetFdInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMemoryGetFdInfoKHR(vkb_dec *d, VkMemoryGetFdInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMemoryGetFdInfoKHR(d, s); +} + +void vkb_encfix_VkMemoryOpaqueCaptureAddressAllocateInfo(vkb_enc *e, const VkMemoryOpaqueCaptureAddressAllocateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMemoryOpaqueCaptureAddressAllocateInfo(vkb_enc *e, const VkMemoryOpaqueCaptureAddressAllocateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMemoryOpaqueCaptureAddressAllocateInfo(e, s, raw); +} + +void vkb_decfix_VkMemoryOpaqueCaptureAddressAllocateInfo(vkb_dec *d, VkMemoryOpaqueCaptureAddressAllocateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMemoryOpaqueCaptureAddressAllocateInfo(vkb_dec *d, VkMemoryOpaqueCaptureAddressAllocateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMemoryOpaqueCaptureAddressAllocateInfo(d, s); +} + +void vkb_encfix_VkMemoryPriorityAllocateInfoEXT(vkb_enc *e, const VkMemoryPriorityAllocateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMemoryPriorityAllocateInfoEXT(vkb_enc *e, const VkMemoryPriorityAllocateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMemoryPriorityAllocateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkMemoryPriorityAllocateInfoEXT(vkb_dec *d, VkMemoryPriorityAllocateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMemoryPriorityAllocateInfoEXT(vkb_dec *d, VkMemoryPriorityAllocateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMemoryPriorityAllocateInfoEXT(d, s); +} + +void vkb_encfix_VkMemoryRequirements2(vkb_enc *e, const VkMemoryRequirements2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMemoryRequirements2(vkb_enc *e, const VkMemoryRequirements2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMemoryRequirements2(e, s, raw); +} + +void vkb_decfix_VkMemoryRequirements2(vkb_dec *d, VkMemoryRequirements2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMemoryRequirements2(vkb_dec *d, VkMemoryRequirements2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMemoryRequirements2(d, s); +} + +void vkb_encfix_VkMultisamplePropertiesEXT(vkb_enc *e, const VkMultisamplePropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMultisamplePropertiesEXT(vkb_enc *e, const VkMultisamplePropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMultisamplePropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkMultisamplePropertiesEXT(vkb_dec *d, VkMultisamplePropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMultisamplePropertiesEXT(vkb_dec *d, VkMultisamplePropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMultisamplePropertiesEXT(d, s); +} + +void vkb_encfix_VkMultisampledRenderToSingleSampledInfoEXT(vkb_enc *e, const VkMultisampledRenderToSingleSampledInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkMultisampledRenderToSingleSampledInfoEXT(vkb_enc *e, const VkMultisampledRenderToSingleSampledInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMultisampledRenderToSingleSampledInfoEXT(e, s, raw); +} + +void vkb_decfix_VkMultisampledRenderToSingleSampledInfoEXT(vkb_dec *d, VkMultisampledRenderToSingleSampledInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkMultisampledRenderToSingleSampledInfoEXT(vkb_dec *d, VkMultisampledRenderToSingleSampledInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMultisampledRenderToSingleSampledInfoEXT(d, s); +} + +void vkb_encfix_VkMutableDescriptorTypeCreateInfoEXT(vkb_enc *e, const VkMutableDescriptorTypeCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pMutableDescriptorTypeLists) { + uint32_t n_ = (uint32_t)(s->mutableDescriptorTypeListCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkMutableDescriptorTypeListEXT(e, &s->pMutableDescriptorTypeLists[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkMutableDescriptorTypeCreateInfoEXT(vkb_enc *e, const VkMutableDescriptorTypeCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMutableDescriptorTypeCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkMutableDescriptorTypeCreateInfoEXT(vkb_dec *d, VkMutableDescriptorTypeCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkMutableDescriptorTypeListEXT *a_ = (VkMutableDescriptorTypeListEXT *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkMutableDescriptorTypeListEXT)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkMutableDescriptorTypeListEXT(d, &a_[i_]); + s->pMutableDescriptorTypeLists = a_; + } else { + s->pMutableDescriptorTypeLists = NULL; + } +} + +void vkb_dec_VkMutableDescriptorTypeCreateInfoEXT(vkb_dec *d, VkMutableDescriptorTypeCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMutableDescriptorTypeCreateInfoEXT(d, s); +} + +void vkb_encfix_VkMutableDescriptorTypeListEXT(vkb_enc *e, const VkMutableDescriptorTypeListEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + if (s->pDescriptorTypes) { + uint32_t n_ = (uint32_t)(s->descriptorTypeCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDescriptorTypes, (size_t)n_ * sizeof(*s->pDescriptorTypes)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkMutableDescriptorTypeListEXT(vkb_enc *e, const VkMutableDescriptorTypeListEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkMutableDescriptorTypeListEXT(e, s, raw); +} + +void vkb_decfix_VkMutableDescriptorTypeListEXT(vkb_dec *d, VkMutableDescriptorTypeListEXT *s) +{ + (void)d; (void)s; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDescriptorTypes = (const VkDescriptorType *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDescriptorType)); + } else { + s->pDescriptorTypes = NULL; + } +} + +void vkb_dec_VkMutableDescriptorTypeListEXT(vkb_dec *d, VkMutableDescriptorTypeListEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkMutableDescriptorTypeListEXT(d, s); +} + +void vkb_encfix_VkPhysicalDevice16BitStorageFeatures(vkb_enc *e, const VkPhysicalDevice16BitStorageFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevice16BitStorageFeatures(vkb_enc *e, const VkPhysicalDevice16BitStorageFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevice16BitStorageFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevice16BitStorageFeatures(vkb_dec *d, VkPhysicalDevice16BitStorageFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevice16BitStorageFeatures(vkb_dec *d, VkPhysicalDevice16BitStorageFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevice16BitStorageFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDevice4444FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDevice4444FormatsFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevice4444FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDevice4444FormatsFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevice4444FormatsFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevice4444FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDevice4444FormatsFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevice4444FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDevice4444FormatsFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevice4444FormatsFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDevice8BitStorageFeatures(vkb_enc *e, const VkPhysicalDevice8BitStorageFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevice8BitStorageFeatures(vkb_enc *e, const VkPhysicalDevice8BitStorageFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevice8BitStorageFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevice8BitStorageFeatures(vkb_dec *d, VkPhysicalDevice8BitStorageFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevice8BitStorageFeatures(vkb_dec *d, VkPhysicalDevice8BitStorageFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevice8BitStorageFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceASTCDecodeFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceASTCDecodeFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceASTCDecodeFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkb_dec *d, VkPhysicalDeviceASTCDecodeFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkb_dec *d, VkPhysicalDeviceASTCDecodeFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceASTCDecodeFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(vkb_dec *d, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(vkb_dec *d, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkb_dec *d, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkb_dec *d, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceBufferDeviceAddressFeatures(vkb_enc *e, const VkPhysicalDeviceBufferDeviceAddressFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceBufferDeviceAddressFeatures(vkb_enc *e, const VkPhysicalDeviceBufferDeviceAddressFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceBufferDeviceAddressFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceBufferDeviceAddressFeatures(vkb_dec *d, VkPhysicalDeviceBufferDeviceAddressFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceBufferDeviceAddressFeatures(vkb_dec *d, VkPhysicalDeviceBufferDeviceAddressFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceBufferDeviceAddressFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkb_dec *d, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceColorWriteEnableFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceColorWriteEnableFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceColorWriteEnableFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceColorWriteEnableFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceColorWriteEnableFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceColorWriteEnableFeaturesEXT(vkb_dec *d, VkPhysicalDeviceColorWriteEnableFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceColorWriteEnableFeaturesEXT(vkb_dec *d, VkPhysicalDeviceColorWriteEnableFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceColorWriteEnableFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceConditionalRenderingFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceConditionalRenderingFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkb_dec *d, VkPhysicalDeviceConditionalRenderingFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkb_dec *d, VkPhysicalDeviceConditionalRenderingFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceConditionalRenderingFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkb_dec *d, VkPhysicalDeviceConservativeRasterizationPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkb_dec *d, VkPhysicalDeviceConservativeRasterizationPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceCustomBorderColorFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceCustomBorderColorFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkb_dec *d, VkPhysicalDeviceCustomBorderColorFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkb_dec *d, VkPhysicalDeviceCustomBorderColorFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceCustomBorderColorFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceCustomBorderColorPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceCustomBorderColorPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceCustomBorderColorPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkb_dec *d, VkPhysicalDeviceCustomBorderColorPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkb_dec *d, VkPhysicalDeviceCustomBorderColorPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceCustomBorderColorPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceDepthClipControlFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClipControlFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceDepthClipControlFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClipControlFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceDepthClipControlFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceDepthClipControlFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClipControlFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceDepthClipControlFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClipControlFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceDepthClipControlFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceDepthClipEnableFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceDepthClipEnableFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceDepthClipEnableFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceDepthClipEnableFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceDepthClipEnableFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClipEnableFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceDepthClipEnableFeaturesEXT(vkb_dec *d, VkPhysicalDeviceDepthClipEnableFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceDepthClipEnableFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceDepthStencilResolveProperties(vkb_enc *e, const VkPhysicalDeviceDepthStencilResolveProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceDepthStencilResolveProperties(vkb_enc *e, const VkPhysicalDeviceDepthStencilResolveProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceDepthStencilResolveProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceDepthStencilResolveProperties(vkb_dec *d, VkPhysicalDeviceDepthStencilResolveProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceDepthStencilResolveProperties(vkb_dec *d, VkPhysicalDeviceDepthStencilResolveProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceDepthStencilResolveProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceDescriptorIndexingFeatures(vkb_enc *e, const VkPhysicalDeviceDescriptorIndexingFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceDescriptorIndexingFeatures(vkb_enc *e, const VkPhysicalDeviceDescriptorIndexingFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceDescriptorIndexingFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceDescriptorIndexingFeatures(vkb_dec *d, VkPhysicalDeviceDescriptorIndexingFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceDescriptorIndexingFeatures(vkb_dec *d, VkPhysicalDeviceDescriptorIndexingFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceDescriptorIndexingFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceDescriptorIndexingProperties(vkb_enc *e, const VkPhysicalDeviceDescriptorIndexingProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceDescriptorIndexingProperties(vkb_enc *e, const VkPhysicalDeviceDescriptorIndexingProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceDescriptorIndexingProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceDescriptorIndexingProperties(vkb_dec *d, VkPhysicalDeviceDescriptorIndexingProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceDescriptorIndexingProperties(vkb_dec *d, VkPhysicalDeviceDescriptorIndexingProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceDescriptorIndexingProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkb_enc *e, const VkPhysicalDeviceDiscardRectanglePropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkb_enc *e, const VkPhysicalDeviceDiscardRectanglePropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceDiscardRectanglePropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkb_dec *d, VkPhysicalDeviceDiscardRectanglePropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkb_dec *d, VkPhysicalDeviceDiscardRectanglePropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceDiscardRectanglePropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceDriverProperties(vkb_enc *e, const VkPhysicalDeviceDriverProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceDriverProperties(vkb_enc *e, const VkPhysicalDeviceDriverProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceDriverProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceDriverProperties(vkb_dec *d, VkPhysicalDeviceDriverProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceDriverProperties(vkb_dec *d, VkPhysicalDeviceDriverProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceDriverProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceDrmPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceDrmPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceDrmPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceDrmPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceDrmPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceDrmPropertiesEXT(vkb_dec *d, VkPhysicalDeviceDrmPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceDrmPropertiesEXT(vkb_dec *d, VkPhysicalDeviceDrmPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceDrmPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceDynamicRenderingFeatures(vkb_enc *e, const VkPhysicalDeviceDynamicRenderingFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceDynamicRenderingFeatures(vkb_enc *e, const VkPhysicalDeviceDynamicRenderingFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceDynamicRenderingFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceDynamicRenderingFeatures(vkb_dec *d, VkPhysicalDeviceDynamicRenderingFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceDynamicRenderingFeatures(vkb_dec *d, VkPhysicalDeviceDynamicRenderingFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceDynamicRenderingFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkb_dec *d, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceExternalBufferInfo(vkb_enc *e, const VkPhysicalDeviceExternalBufferInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceExternalBufferInfo(vkb_enc *e, const VkPhysicalDeviceExternalBufferInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceExternalBufferInfo(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceExternalBufferInfo(vkb_dec *d, VkPhysicalDeviceExternalBufferInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceExternalBufferInfo(vkb_dec *d, VkPhysicalDeviceExternalBufferInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceExternalBufferInfo(d, s); +} + +void vkb_encfix_VkPhysicalDeviceExternalFenceInfo(vkb_enc *e, const VkPhysicalDeviceExternalFenceInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceExternalFenceInfo(vkb_enc *e, const VkPhysicalDeviceExternalFenceInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceExternalFenceInfo(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceExternalFenceInfo(vkb_dec *d, VkPhysicalDeviceExternalFenceInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceExternalFenceInfo(vkb_dec *d, VkPhysicalDeviceExternalFenceInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceExternalFenceInfo(d, s); +} + +void vkb_encfix_VkPhysicalDeviceExternalImageFormatInfo(vkb_enc *e, const VkPhysicalDeviceExternalImageFormatInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceExternalImageFormatInfo(vkb_enc *e, const VkPhysicalDeviceExternalImageFormatInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceExternalImageFormatInfo(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceExternalImageFormatInfo(vkb_dec *d, VkPhysicalDeviceExternalImageFormatInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceExternalImageFormatInfo(vkb_dec *d, VkPhysicalDeviceExternalImageFormatInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceExternalImageFormatInfo(d, s); +} + +void vkb_encfix_VkPhysicalDeviceExternalSemaphoreInfo(vkb_enc *e, const VkPhysicalDeviceExternalSemaphoreInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceExternalSemaphoreInfo(vkb_enc *e, const VkPhysicalDeviceExternalSemaphoreInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceExternalSemaphoreInfo(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceExternalSemaphoreInfo(vkb_dec *d, VkPhysicalDeviceExternalSemaphoreInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceExternalSemaphoreInfo(vkb_dec *d, VkPhysicalDeviceExternalSemaphoreInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceExternalSemaphoreInfo(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFeatures2(vkb_enc *e, const VkPhysicalDeviceFeatures2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFeatures2(vkb_enc *e, const VkPhysicalDeviceFeatures2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFeatures2(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFeatures2(vkb_dec *d, VkPhysicalDeviceFeatures2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFeatures2(vkb_dec *d, VkPhysicalDeviceFeatures2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFeatures2(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFloatControlsProperties(vkb_enc *e, const VkPhysicalDeviceFloatControlsProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFloatControlsProperties(vkb_enc *e, const VkPhysicalDeviceFloatControlsProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFloatControlsProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFloatControlsProperties(vkb_dec *d, VkPhysicalDeviceFloatControlsProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFloatControlsProperties(vkb_dec *d, VkPhysicalDeviceFloatControlsProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFloatControlsProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMapFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMapFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMapPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkb_dec *d, VkPhysicalDeviceFragmentDensityMapPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(vkb_dec *d, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRateFeaturesKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRateFeaturesKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFragmentShadingRateKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRateKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFragmentShadingRateKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRateKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFragmentShadingRateKHR(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFragmentShadingRateKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRateKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFragmentShadingRateKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRateKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFragmentShadingRateKHR(d, s); +} + +void vkb_encfix_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkb_enc *e, const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRatePropertiesKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkb_dec *d, VkPhysicalDeviceFragmentShadingRatePropertiesKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(d, s); +} + +void vkb_encfix_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(vkb_dec *d, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(vkb_dec *d, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(d, s); +} + +void vkb_encfix_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(vkb_dec *d, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(vkb_dec *d, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(vkb_dec *d, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(vkb_dec *d, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceGroupProperties(vkb_enc *e, const VkPhysicalDeviceGroupProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + for (size_t i_ = 0; i_ < sizeof(s->physicalDevices) / sizeof(s->physicalDevices[0]); i_++) vkb_enc_patch_u64(e, raw + offsetof(VkPhysicalDeviceGroupProperties, physicalDevices) + i_ * 8, vkb_remote((const void *)s->physicalDevices[i_])); +} + +void vkb_enc_VkPhysicalDeviceGroupProperties(vkb_enc *e, const VkPhysicalDeviceGroupProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceGroupProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceGroupProperties(vkb_dec *d, VkPhysicalDeviceGroupProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceGroupProperties(vkb_dec *d, VkPhysicalDeviceGroupProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceGroupProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceHostQueryResetFeatures(vkb_enc *e, const VkPhysicalDeviceHostQueryResetFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceHostQueryResetFeatures(vkb_enc *e, const VkPhysicalDeviceHostQueryResetFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceHostQueryResetFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceHostQueryResetFeatures(vkb_dec *d, VkPhysicalDeviceHostQueryResetFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceHostQueryResetFeatures(vkb_dec *d, VkPhysicalDeviceHostQueryResetFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceHostQueryResetFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceIDProperties(vkb_enc *e, const VkPhysicalDeviceIDProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceIDProperties(vkb_enc *e, const VkPhysicalDeviceIDProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceIDProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceIDProperties(vkb_dec *d, VkPhysicalDeviceIDProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceIDProperties(vkb_dec *d, VkPhysicalDeviceIDProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceIDProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceImageCompressionControlFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageCompressionControlFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceImageCompressionControlFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageCompressionControlFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceImageCompressionControlFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceImageCompressionControlFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageCompressionControlFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceImageCompressionControlFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageCompressionControlFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceImageCompressionControlFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(vkb_enc *e, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pQueueFamilyIndices && (s->sharingMode == VK_SHARING_MODE_CONCURRENT)) { + uint32_t n_ = (uint32_t)(s->queueFamilyIndexCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pQueueFamilyIndices, (size_t)n_ * sizeof(*s->pQueueFamilyIndices)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(vkb_enc *e, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(vkb_dec *d, VkPhysicalDeviceImageDrmFormatModifierInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pQueueFamilyIndices = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pQueueFamilyIndices = NULL; + } +} + +void vkb_dec_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(vkb_dec *d, VkPhysicalDeviceImageDrmFormatModifierInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceImageFormatInfo2(vkb_enc *e, const VkPhysicalDeviceImageFormatInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceImageFormatInfo2(vkb_enc *e, const VkPhysicalDeviceImageFormatInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceImageFormatInfo2(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceImageFormatInfo2(vkb_dec *d, VkPhysicalDeviceImageFormatInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceImageFormatInfo2(vkb_dec *d, VkPhysicalDeviceImageFormatInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceImageFormatInfo2(d, s); +} + +void vkb_encfix_VkPhysicalDeviceImageRobustnessFeatures(vkb_enc *e, const VkPhysicalDeviceImageRobustnessFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceImageRobustnessFeatures(vkb_enc *e, const VkPhysicalDeviceImageRobustnessFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceImageRobustnessFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceImageRobustnessFeatures(vkb_dec *d, VkPhysicalDeviceImageRobustnessFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceImageRobustnessFeatures(vkb_dec *d, VkPhysicalDeviceImageRobustnessFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceImageRobustnessFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceImageViewImageFormatInfoEXT(vkb_enc *e, const VkPhysicalDeviceImageViewImageFormatInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceImageViewImageFormatInfoEXT(vkb_enc *e, const VkPhysicalDeviceImageViewImageFormatInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceImageViewImageFormatInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceImageViewImageFormatInfoEXT(vkb_dec *d, VkPhysicalDeviceImageViewImageFormatInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceImageViewImageFormatInfoEXT(vkb_dec *d, VkPhysicalDeviceImageViewImageFormatInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceImageViewImageFormatInfoEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceImageViewMinLodFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceImageViewMinLodFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceImageViewMinLodFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceImageViewMinLodFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceImageViewMinLodFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageViewMinLodFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceImageViewMinLodFeaturesEXT(vkb_dec *d, VkPhysicalDeviceImageViewMinLodFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceImageViewMinLodFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceImagelessFramebufferFeatures(vkb_enc *e, const VkPhysicalDeviceImagelessFramebufferFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceImagelessFramebufferFeatures(vkb_enc *e, const VkPhysicalDeviceImagelessFramebufferFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceImagelessFramebufferFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceImagelessFramebufferFeatures(vkb_dec *d, VkPhysicalDeviceImagelessFramebufferFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceImagelessFramebufferFeatures(vkb_dec *d, VkPhysicalDeviceImagelessFramebufferFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceImagelessFramebufferFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(vkb_dec *d, VkPhysicalDeviceIndexTypeUint8FeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(vkb_dec *d, VkPhysicalDeviceIndexTypeUint8FeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceInlineUniformBlockFeatures(vkb_enc *e, const VkPhysicalDeviceInlineUniformBlockFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceInlineUniformBlockFeatures(vkb_enc *e, const VkPhysicalDeviceInlineUniformBlockFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceInlineUniformBlockFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceInlineUniformBlockFeatures(vkb_dec *d, VkPhysicalDeviceInlineUniformBlockFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceInlineUniformBlockFeatures(vkb_dec *d, VkPhysicalDeviceInlineUniformBlockFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceInlineUniformBlockFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceInlineUniformBlockProperties(vkb_enc *e, const VkPhysicalDeviceInlineUniformBlockProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceInlineUniformBlockProperties(vkb_enc *e, const VkPhysicalDeviceInlineUniformBlockProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceInlineUniformBlockProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceInlineUniformBlockProperties(vkb_dec *d, VkPhysicalDeviceInlineUniformBlockProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceInlineUniformBlockProperties(vkb_dec *d, VkPhysicalDeviceInlineUniformBlockProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceInlineUniformBlockProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceLegacyDitheringFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceLegacyDitheringFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceLegacyDitheringFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceLegacyDitheringFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceLegacyDitheringFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceLegacyDitheringFeaturesEXT(vkb_dec *d, VkPhysicalDeviceLegacyDitheringFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceLegacyDitheringFeaturesEXT(vkb_dec *d, VkPhysicalDeviceLegacyDitheringFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceLegacyDitheringFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceLineRasterizationFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceLineRasterizationFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceLineRasterizationFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkb_dec *d, VkPhysicalDeviceLineRasterizationFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkb_dec *d, VkPhysicalDeviceLineRasterizationFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceLineRasterizationFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceLineRasterizationPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceLineRasterizationPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceLineRasterizationPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkb_dec *d, VkPhysicalDeviceLineRasterizationPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkb_dec *d, VkPhysicalDeviceLineRasterizationPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceLineRasterizationPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMaintenance3Properties(vkb_enc *e, const VkPhysicalDeviceMaintenance3Properties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMaintenance3Properties(vkb_enc *e, const VkPhysicalDeviceMaintenance3Properties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMaintenance3Properties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMaintenance3Properties(vkb_dec *d, VkPhysicalDeviceMaintenance3Properties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMaintenance3Properties(vkb_dec *d, VkPhysicalDeviceMaintenance3Properties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMaintenance3Properties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMaintenance4Features(vkb_enc *e, const VkPhysicalDeviceMaintenance4Features *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMaintenance4Features(vkb_enc *e, const VkPhysicalDeviceMaintenance4Features *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMaintenance4Features(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMaintenance4Features(vkb_dec *d, VkPhysicalDeviceMaintenance4Features *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMaintenance4Features(vkb_dec *d, VkPhysicalDeviceMaintenance4Features *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMaintenance4Features(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMaintenance4Properties(vkb_enc *e, const VkPhysicalDeviceMaintenance4Properties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMaintenance4Properties(vkb_enc *e, const VkPhysicalDeviceMaintenance4Properties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMaintenance4Properties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMaintenance4Properties(vkb_dec *d, VkPhysicalDeviceMaintenance4Properties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMaintenance4Properties(vkb_dec *d, VkPhysicalDeviceMaintenance4Properties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMaintenance4Properties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMemoryBudgetPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceMemoryBudgetPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMemoryBudgetPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceMemoryBudgetPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMemoryBudgetPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMemoryBudgetPropertiesEXT(vkb_dec *d, VkPhysicalDeviceMemoryBudgetPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMemoryBudgetPropertiesEXT(vkb_dec *d, VkPhysicalDeviceMemoryBudgetPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMemoryBudgetPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMemoryPriorityFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMemoryPriorityFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMemoryPriorityFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMemoryPriorityFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMemoryPriorityFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMemoryPriorityFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMemoryProperties2(vkb_enc *e, const VkPhysicalDeviceMemoryProperties2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMemoryProperties2(vkb_enc *e, const VkPhysicalDeviceMemoryProperties2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMemoryProperties2(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMemoryProperties2(vkb_dec *d, VkPhysicalDeviceMemoryProperties2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMemoryProperties2(vkb_dec *d, VkPhysicalDeviceMemoryProperties2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMemoryProperties2(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMultiDrawFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMultiDrawFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMultiDrawFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMultiDrawFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMultiDrawFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMultiDrawFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMultiDrawFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMultiDrawFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMultiDrawFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMultiDrawFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMultiDrawPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceMultiDrawPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMultiDrawPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceMultiDrawPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMultiDrawPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMultiDrawPropertiesEXT(vkb_dec *d, VkPhysicalDeviceMultiDrawPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMultiDrawPropertiesEXT(vkb_dec *d, VkPhysicalDeviceMultiDrawPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMultiDrawPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMultiviewFeatures(vkb_enc *e, const VkPhysicalDeviceMultiviewFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMultiviewFeatures(vkb_enc *e, const VkPhysicalDeviceMultiviewFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMultiviewFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMultiviewFeatures(vkb_dec *d, VkPhysicalDeviceMultiviewFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMultiviewFeatures(vkb_dec *d, VkPhysicalDeviceMultiviewFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMultiviewFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMultiviewProperties(vkb_enc *e, const VkPhysicalDeviceMultiviewProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMultiviewProperties(vkb_enc *e, const VkPhysicalDeviceMultiviewProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMultiviewProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMultiviewProperties(vkb_dec *d, VkPhysicalDeviceMultiviewProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMultiviewProperties(vkb_dec *d, VkPhysicalDeviceMultiviewProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMultiviewProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(vkb_dec *d, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(vkb_dec *d, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(vkb_dec *d, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDevicePCIBusInfoPropertiesEXT(vkb_enc *e, const VkPhysicalDevicePCIBusInfoPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevicePCIBusInfoPropertiesEXT(vkb_enc *e, const VkPhysicalDevicePCIBusInfoPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevicePCIBusInfoPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevicePCIBusInfoPropertiesEXT(vkb_dec *d, VkPhysicalDevicePCIBusInfoPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevicePCIBusInfoPropertiesEXT(vkb_dec *d, VkPhysicalDevicePCIBusInfoPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevicePCIBusInfoPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(vkb_dec *d, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(vkb_dec *d, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDevicePipelineCreationCacheControlFeatures(vkb_enc *e, const VkPhysicalDevicePipelineCreationCacheControlFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevicePipelineCreationCacheControlFeatures(vkb_enc *e, const VkPhysicalDevicePipelineCreationCacheControlFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevicePipelineCreationCacheControlFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevicePipelineCreationCacheControlFeatures(vkb_dec *d, VkPhysicalDevicePipelineCreationCacheControlFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevicePipelineCreationCacheControlFeatures(vkb_dec *d, VkPhysicalDevicePipelineCreationCacheControlFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevicePipelineCreationCacheControlFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(vkb_dec *d, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(vkb_dec *d, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDevicePipelineRobustnessFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePipelineRobustnessFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevicePipelineRobustnessFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePipelineRobustnessFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevicePipelineRobustnessFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevicePipelineRobustnessFeaturesEXT(vkb_dec *d, VkPhysicalDevicePipelineRobustnessFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevicePipelineRobustnessFeaturesEXT(vkb_dec *d, VkPhysicalDevicePipelineRobustnessFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevicePipelineRobustnessFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDevicePipelineRobustnessPropertiesEXT(vkb_enc *e, const VkPhysicalDevicePipelineRobustnessPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevicePipelineRobustnessPropertiesEXT(vkb_enc *e, const VkPhysicalDevicePipelineRobustnessPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevicePipelineRobustnessPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevicePipelineRobustnessPropertiesEXT(vkb_dec *d, VkPhysicalDevicePipelineRobustnessPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevicePipelineRobustnessPropertiesEXT(vkb_dec *d, VkPhysicalDevicePipelineRobustnessPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevicePipelineRobustnessPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDevicePointClippingProperties(vkb_enc *e, const VkPhysicalDevicePointClippingProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevicePointClippingProperties(vkb_enc *e, const VkPhysicalDevicePointClippingProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevicePointClippingProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevicePointClippingProperties(vkb_dec *d, VkPhysicalDevicePointClippingProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevicePointClippingProperties(vkb_dec *d, VkPhysicalDevicePointClippingProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevicePointClippingProperties(d, s); +} + +void vkb_encfix_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(vkb_dec *d, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(vkb_dec *d, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(vkb_enc *e, const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(vkb_dec *d, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(vkb_dec *d, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDevicePrivateDataFeatures(vkb_enc *e, const VkPhysicalDevicePrivateDataFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevicePrivateDataFeatures(vkb_enc *e, const VkPhysicalDevicePrivateDataFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevicePrivateDataFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevicePrivateDataFeatures(vkb_dec *d, VkPhysicalDevicePrivateDataFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevicePrivateDataFeatures(vkb_dec *d, VkPhysicalDevicePrivateDataFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevicePrivateDataFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceProperties2(vkb_enc *e, const VkPhysicalDeviceProperties2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceProperties2(vkb_enc *e, const VkPhysicalDeviceProperties2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceProperties2(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceProperties2(vkb_dec *d, VkPhysicalDeviceProperties2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceProperties2(vkb_dec *d, VkPhysicalDeviceProperties2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceProperties2(d, s); +} + +void vkb_encfix_VkPhysicalDeviceProtectedMemoryFeatures(vkb_enc *e, const VkPhysicalDeviceProtectedMemoryFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceProtectedMemoryFeatures(vkb_enc *e, const VkPhysicalDeviceProtectedMemoryFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceProtectedMemoryFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceProtectedMemoryFeatures(vkb_dec *d, VkPhysicalDeviceProtectedMemoryFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceProtectedMemoryFeatures(vkb_dec *d, VkPhysicalDeviceProtectedMemoryFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceProtectedMemoryFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceProtectedMemoryProperties(vkb_enc *e, const VkPhysicalDeviceProtectedMemoryProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceProtectedMemoryProperties(vkb_enc *e, const VkPhysicalDeviceProtectedMemoryProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceProtectedMemoryProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceProtectedMemoryProperties(vkb_dec *d, VkPhysicalDeviceProtectedMemoryProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceProtectedMemoryProperties(vkb_dec *d, VkPhysicalDeviceProtectedMemoryProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceProtectedMemoryProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceProvokingVertexFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceProvokingVertexFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceProvokingVertexFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceProvokingVertexFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceProvokingVertexFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceProvokingVertexFeaturesEXT(vkb_dec *d, VkPhysicalDeviceProvokingVertexFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceProvokingVertexFeaturesEXT(vkb_dec *d, VkPhysicalDeviceProvokingVertexFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceProvokingVertexFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceProvokingVertexPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceProvokingVertexPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceProvokingVertexPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceProvokingVertexPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceProvokingVertexPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceProvokingVertexPropertiesEXT(vkb_dec *d, VkPhysicalDeviceProvokingVertexPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceProvokingVertexPropertiesEXT(vkb_dec *d, VkPhysicalDeviceProvokingVertexPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceProvokingVertexPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDevicePushDescriptorPropertiesKHR(vkb_enc *e, const VkPhysicalDevicePushDescriptorPropertiesKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDevicePushDescriptorPropertiesKHR(vkb_enc *e, const VkPhysicalDevicePushDescriptorPropertiesKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDevicePushDescriptorPropertiesKHR(e, s, raw); +} + +void vkb_decfix_VkPhysicalDevicePushDescriptorPropertiesKHR(vkb_dec *d, VkPhysicalDevicePushDescriptorPropertiesKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDevicePushDescriptorPropertiesKHR(vkb_dec *d, VkPhysicalDevicePushDescriptorPropertiesKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDevicePushDescriptorPropertiesKHR(d, s); +} + +void vkb_encfix_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(vkb_dec *d, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(vkb_dec *d, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceRobustness2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRobustness2FeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceRobustness2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceRobustness2FeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceRobustness2FeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceRobustness2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceRobustness2FeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceRobustness2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceRobustness2FeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceRobustness2FeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceRobustness2PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceRobustness2PropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceRobustness2PropertiesEXT(vkb_enc *e, const VkPhysicalDeviceRobustness2PropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceRobustness2PropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceRobustness2PropertiesEXT(vkb_dec *d, VkPhysicalDeviceRobustness2PropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceRobustness2PropertiesEXT(vkb_dec *d, VkPhysicalDeviceRobustness2PropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceRobustness2PropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceSampleLocationsPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceSampleLocationsPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceSampleLocationsPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkb_dec *d, VkPhysicalDeviceSampleLocationsPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkb_dec *d, VkPhysicalDeviceSampleLocationsPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceSampleLocationsPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkb_enc *e, const VkPhysicalDeviceSamplerFilterMinmaxProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkb_enc *e, const VkPhysicalDeviceSamplerFilterMinmaxProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceSamplerFilterMinmaxProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkb_dec *d, VkPhysicalDeviceSamplerFilterMinmaxProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkb_dec *d, VkPhysicalDeviceSamplerFilterMinmaxProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceSamplerFilterMinmaxProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkb_enc *e, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkb_enc *e, const VkPhysicalDeviceSamplerYcbcrConversionFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceSamplerYcbcrConversionFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkb_dec *d, VkPhysicalDeviceSamplerYcbcrConversionFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkb_dec *d, VkPhysicalDeviceSamplerYcbcrConversionFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceSamplerYcbcrConversionFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceScalarBlockLayoutFeatures(vkb_enc *e, const VkPhysicalDeviceScalarBlockLayoutFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceScalarBlockLayoutFeatures(vkb_enc *e, const VkPhysicalDeviceScalarBlockLayoutFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceScalarBlockLayoutFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceScalarBlockLayoutFeatures(vkb_dec *d, VkPhysicalDeviceScalarBlockLayoutFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceScalarBlockLayoutFeatures(vkb_dec *d, VkPhysicalDeviceScalarBlockLayoutFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceScalarBlockLayoutFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkb_enc *e, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkb_enc *e, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkb_dec *d, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkb_dec *d, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderAtomicInt64Features(vkb_enc *e, const VkPhysicalDeviceShaderAtomicInt64Features *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderAtomicInt64Features(vkb_enc *e, const VkPhysicalDeviceShaderAtomicInt64Features *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderAtomicInt64Features(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderAtomicInt64Features(vkb_dec *d, VkPhysicalDeviceShaderAtomicInt64Features *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderAtomicInt64Features(vkb_dec *d, VkPhysicalDeviceShaderAtomicInt64Features *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderAtomicInt64Features(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderClockFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceShaderClockFeaturesKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderClockFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceShaderClockFeaturesKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderClockFeaturesKHR(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderClockFeaturesKHR(vkb_dec *d, VkPhysicalDeviceShaderClockFeaturesKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderClockFeaturesKHR(vkb_dec *d, VkPhysicalDeviceShaderClockFeaturesKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderClockFeaturesKHR(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(vkb_enc *e, const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(vkb_enc *e, const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(vkb_dec *d, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(vkb_dec *d, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(vkb_enc *e, const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(vkb_enc *e, const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(vkb_dec *d, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(vkb_dec *d, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderCorePropertiesARM(vkb_enc *e, const VkPhysicalDeviceShaderCorePropertiesARM *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderCorePropertiesARM(vkb_enc *e, const VkPhysicalDeviceShaderCorePropertiesARM *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderCorePropertiesARM(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderCorePropertiesARM(vkb_dec *d, VkPhysicalDeviceShaderCorePropertiesARM *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderCorePropertiesARM(vkb_dec *d, VkPhysicalDeviceShaderCorePropertiesARM *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderCorePropertiesARM(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(vkb_enc *e, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(vkb_enc *e, const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(vkb_dec *d, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(vkb_dec *d, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderDrawParametersFeatures(vkb_enc *e, const VkPhysicalDeviceShaderDrawParametersFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderDrawParametersFeatures(vkb_enc *e, const VkPhysicalDeviceShaderDrawParametersFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderDrawParametersFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderDrawParametersFeatures(vkb_dec *d, VkPhysicalDeviceShaderDrawParametersFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderDrawParametersFeatures(vkb_dec *d, VkPhysicalDeviceShaderDrawParametersFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderDrawParametersFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderFloat16Int8Features(vkb_enc *e, const VkPhysicalDeviceShaderFloat16Int8Features *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderFloat16Int8Features(vkb_enc *e, const VkPhysicalDeviceShaderFloat16Int8Features *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderFloat16Int8Features(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderFloat16Int8Features(vkb_dec *d, VkPhysicalDeviceShaderFloat16Int8Features *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderFloat16Int8Features(vkb_dec *d, VkPhysicalDeviceShaderFloat16Int8Features *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderFloat16Int8Features(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderIntegerDotProductFeatures(vkb_enc *e, const VkPhysicalDeviceShaderIntegerDotProductFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderIntegerDotProductFeatures(vkb_enc *e, const VkPhysicalDeviceShaderIntegerDotProductFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderIntegerDotProductFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderIntegerDotProductFeatures(vkb_dec *d, VkPhysicalDeviceShaderIntegerDotProductFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderIntegerDotProductFeatures(vkb_dec *d, VkPhysicalDeviceShaderIntegerDotProductFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderIntegerDotProductFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderIntegerDotProductProperties(vkb_enc *e, const VkPhysicalDeviceShaderIntegerDotProductProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderIntegerDotProductProperties(vkb_enc *e, const VkPhysicalDeviceShaderIntegerDotProductProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderIntegerDotProductProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderIntegerDotProductProperties(vkb_dec *d, VkPhysicalDeviceShaderIntegerDotProductProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderIntegerDotProductProperties(vkb_dec *d, VkPhysicalDeviceShaderIntegerDotProductProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderIntegerDotProductProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(vkb_dec *d, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(vkb_dec *d, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkb_enc *e, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkb_enc *e, const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkb_dec *d, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkb_dec *d, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(vkb_dec *d, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(vkb_dec *d, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderTerminateInvocationFeatures(vkb_enc *e, const VkPhysicalDeviceShaderTerminateInvocationFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderTerminateInvocationFeatures(vkb_enc *e, const VkPhysicalDeviceShaderTerminateInvocationFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderTerminateInvocationFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderTerminateInvocationFeatures(vkb_dec *d, VkPhysicalDeviceShaderTerminateInvocationFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderTerminateInvocationFeatures(vkb_dec *d, VkPhysicalDeviceShaderTerminateInvocationFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderTerminateInvocationFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderTileImageFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderTileImageFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderTileImageFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceShaderTileImageFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderTileImageFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderTileImageFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderTileImageFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderTileImageFeaturesEXT(vkb_dec *d, VkPhysicalDeviceShaderTileImageFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderTileImageFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceShaderTileImagePropertiesEXT(vkb_enc *e, const VkPhysicalDeviceShaderTileImagePropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceShaderTileImagePropertiesEXT(vkb_enc *e, const VkPhysicalDeviceShaderTileImagePropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceShaderTileImagePropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceShaderTileImagePropertiesEXT(vkb_dec *d, VkPhysicalDeviceShaderTileImagePropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceShaderTileImagePropertiesEXT(vkb_dec *d, VkPhysicalDeviceShaderTileImagePropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceShaderTileImagePropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceSparseImageFormatInfo2(vkb_enc *e, const VkPhysicalDeviceSparseImageFormatInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceSparseImageFormatInfo2(vkb_enc *e, const VkPhysicalDeviceSparseImageFormatInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceSparseImageFormatInfo2(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceSparseImageFormatInfo2(vkb_dec *d, VkPhysicalDeviceSparseImageFormatInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceSparseImageFormatInfo2(vkb_dec *d, VkPhysicalDeviceSparseImageFormatInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceSparseImageFormatInfo2(d, s); +} + +void vkb_encfix_VkPhysicalDeviceSubgroupProperties(vkb_enc *e, const VkPhysicalDeviceSubgroupProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceSubgroupProperties(vkb_enc *e, const VkPhysicalDeviceSubgroupProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceSubgroupProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceSubgroupProperties(vkb_dec *d, VkPhysicalDeviceSubgroupProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceSubgroupProperties(vkb_dec *d, VkPhysicalDeviceSubgroupProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceSubgroupProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceSubgroupSizeControlFeatures(vkb_enc *e, const VkPhysicalDeviceSubgroupSizeControlFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceSubgroupSizeControlFeatures(vkb_enc *e, const VkPhysicalDeviceSubgroupSizeControlFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceSubgroupSizeControlFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceSubgroupSizeControlFeatures(vkb_dec *d, VkPhysicalDeviceSubgroupSizeControlFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceSubgroupSizeControlFeatures(vkb_dec *d, VkPhysicalDeviceSubgroupSizeControlFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceSubgroupSizeControlFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceSubgroupSizeControlProperties(vkb_enc *e, const VkPhysicalDeviceSubgroupSizeControlProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceSubgroupSizeControlProperties(vkb_enc *e, const VkPhysicalDeviceSubgroupSizeControlProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceSubgroupSizeControlProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceSubgroupSizeControlProperties(vkb_dec *d, VkPhysicalDeviceSubgroupSizeControlProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceSubgroupSizeControlProperties(vkb_dec *d, VkPhysicalDeviceSubgroupSizeControlProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceSubgroupSizeControlProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(vkb_dec *d, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(vkb_dec *d, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceSynchronization2Features(vkb_enc *e, const VkPhysicalDeviceSynchronization2Features *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceSynchronization2Features(vkb_enc *e, const VkPhysicalDeviceSynchronization2Features *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceSynchronization2Features(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceSynchronization2Features(vkb_dec *d, VkPhysicalDeviceSynchronization2Features *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceSynchronization2Features(vkb_dec *d, VkPhysicalDeviceSynchronization2Features *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceSynchronization2Features(d, s); +} + +void vkb_encfix_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkb_dec *d, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkb_dec *d, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceTexelBufferAlignmentProperties(vkb_enc *e, const VkPhysicalDeviceTexelBufferAlignmentProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceTexelBufferAlignmentProperties(vkb_enc *e, const VkPhysicalDeviceTexelBufferAlignmentProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceTexelBufferAlignmentProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceTexelBufferAlignmentProperties(vkb_dec *d, VkPhysicalDeviceTexelBufferAlignmentProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceTexelBufferAlignmentProperties(vkb_dec *d, VkPhysicalDeviceTexelBufferAlignmentProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceTexelBufferAlignmentProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(vkb_enc *e, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(vkb_enc *e, const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(vkb_dec *d, VkPhysicalDeviceTextureCompressionASTCHDRFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(vkb_dec *d, VkPhysicalDeviceTextureCompressionASTCHDRFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceTimelineSemaphoreFeatures(vkb_enc *e, const VkPhysicalDeviceTimelineSemaphoreFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceTimelineSemaphoreFeatures(vkb_enc *e, const VkPhysicalDeviceTimelineSemaphoreFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceTimelineSemaphoreFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceTimelineSemaphoreFeatures(vkb_dec *d, VkPhysicalDeviceTimelineSemaphoreFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceTimelineSemaphoreFeatures(vkb_dec *d, VkPhysicalDeviceTimelineSemaphoreFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceTimelineSemaphoreFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceTimelineSemaphoreProperties(vkb_enc *e, const VkPhysicalDeviceTimelineSemaphoreProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceTimelineSemaphoreProperties(vkb_enc *e, const VkPhysicalDeviceTimelineSemaphoreProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceTimelineSemaphoreProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceTimelineSemaphoreProperties(vkb_dec *d, VkPhysicalDeviceTimelineSemaphoreProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceTimelineSemaphoreProperties(vkb_dec *d, VkPhysicalDeviceTimelineSemaphoreProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceTimelineSemaphoreProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceToolProperties(vkb_enc *e, const VkPhysicalDeviceToolProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceToolProperties(vkb_enc *e, const VkPhysicalDeviceToolProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceToolProperties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceToolProperties(vkb_dec *d, VkPhysicalDeviceToolProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceToolProperties(vkb_dec *d, VkPhysicalDeviceToolProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceToolProperties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceTransformFeedbackFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceTransformFeedbackFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkb_dec *d, VkPhysicalDeviceTransformFeedbackFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkb_dec *d, VkPhysicalDeviceTransformFeedbackFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceTransformFeedbackFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceTransformFeedbackPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceTransformFeedbackPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkb_dec *d, VkPhysicalDeviceTransformFeedbackPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkb_dec *d, VkPhysicalDeviceTransformFeedbackPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceTransformFeedbackPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkb_enc *e, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkb_enc *e, const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkb_dec *d, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkb_dec *d, VkPhysicalDeviceUniformBufferStandardLayoutFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceVariablePointersFeatures(vkb_enc *e, const VkPhysicalDeviceVariablePointersFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceVariablePointersFeatures(vkb_enc *e, const VkPhysicalDeviceVariablePointersFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceVariablePointersFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceVariablePointersFeatures(vkb_dec *d, VkPhysicalDeviceVariablePointersFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceVariablePointersFeatures(vkb_dec *d, VkPhysicalDeviceVariablePointersFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceVariablePointersFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkb_dec *d, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkb_dec *d, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkb_enc *e, const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkb_dec *d, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkb_dec *d, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(vkb_dec *d, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(vkb_dec *d, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceVulkan11Features(vkb_enc *e, const VkPhysicalDeviceVulkan11Features *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceVulkan11Features(vkb_enc *e, const VkPhysicalDeviceVulkan11Features *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceVulkan11Features(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceVulkan11Features(vkb_dec *d, VkPhysicalDeviceVulkan11Features *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceVulkan11Features(vkb_dec *d, VkPhysicalDeviceVulkan11Features *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceVulkan11Features(d, s); +} + +void vkb_encfix_VkPhysicalDeviceVulkan11Properties(vkb_enc *e, const VkPhysicalDeviceVulkan11Properties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceVulkan11Properties(vkb_enc *e, const VkPhysicalDeviceVulkan11Properties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceVulkan11Properties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceVulkan11Properties(vkb_dec *d, VkPhysicalDeviceVulkan11Properties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceVulkan11Properties(vkb_dec *d, VkPhysicalDeviceVulkan11Properties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceVulkan11Properties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceVulkan12Features(vkb_enc *e, const VkPhysicalDeviceVulkan12Features *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceVulkan12Features(vkb_enc *e, const VkPhysicalDeviceVulkan12Features *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceVulkan12Features(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceVulkan12Features(vkb_dec *d, VkPhysicalDeviceVulkan12Features *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceVulkan12Features(vkb_dec *d, VkPhysicalDeviceVulkan12Features *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceVulkan12Features(d, s); +} + +void vkb_encfix_VkPhysicalDeviceVulkan12Properties(vkb_enc *e, const VkPhysicalDeviceVulkan12Properties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceVulkan12Properties(vkb_enc *e, const VkPhysicalDeviceVulkan12Properties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceVulkan12Properties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceVulkan12Properties(vkb_dec *d, VkPhysicalDeviceVulkan12Properties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceVulkan12Properties(vkb_dec *d, VkPhysicalDeviceVulkan12Properties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceVulkan12Properties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceVulkan13Features(vkb_enc *e, const VkPhysicalDeviceVulkan13Features *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceVulkan13Features(vkb_enc *e, const VkPhysicalDeviceVulkan13Features *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceVulkan13Features(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceVulkan13Features(vkb_dec *d, VkPhysicalDeviceVulkan13Features *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceVulkan13Features(vkb_dec *d, VkPhysicalDeviceVulkan13Features *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceVulkan13Features(d, s); +} + +void vkb_encfix_VkPhysicalDeviceVulkan13Properties(vkb_enc *e, const VkPhysicalDeviceVulkan13Properties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceVulkan13Properties(vkb_enc *e, const VkPhysicalDeviceVulkan13Properties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceVulkan13Properties(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceVulkan13Properties(vkb_dec *d, VkPhysicalDeviceVulkan13Properties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceVulkan13Properties(vkb_dec *d, VkPhysicalDeviceVulkan13Properties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceVulkan13Properties(d, s); +} + +void vkb_encfix_VkPhysicalDeviceVulkanMemoryModelFeatures(vkb_enc *e, const VkPhysicalDeviceVulkanMemoryModelFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceVulkanMemoryModelFeatures(vkb_enc *e, const VkPhysicalDeviceVulkanMemoryModelFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceVulkanMemoryModelFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceVulkanMemoryModelFeatures(vkb_dec *d, VkPhysicalDeviceVulkanMemoryModelFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceVulkanMemoryModelFeatures(vkb_dec *d, VkPhysicalDeviceVulkanMemoryModelFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceVulkanMemoryModelFeatures(d, s); +} + +void vkb_encfix_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(vkb_enc *e, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(vkb_dec *d, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(vkb_dec *d, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(d, s); +} + +void vkb_encfix_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(vkb_dec *d, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkb_enc *e, const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkb_dec *d, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkb_dec *d, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(d, s); +} + +void vkb_encfix_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(vkb_enc *e, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(vkb_enc *e, const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(e, s, raw); +} + +void vkb_decfix_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(vkb_dec *d, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(vkb_dec *d, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(d, s); +} + +void vkb_encfix_VkPipelineCacheCreateInfo(vkb_enc *e, const VkPipelineCacheCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_enc_blob(e, s->pInitialData ? (const void *)s->pInitialData : NULL, s->pInitialData ? (size_t)(s->initialDataSize) : 0); +} + +void vkb_enc_VkPipelineCacheCreateInfo(vkb_enc *e, const VkPipelineCacheCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineCacheCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineCacheCreateInfo(vkb_dec *d, VkPipelineCacheCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + s->pInitialData = (const void *)vkb_dec_blob(d, NULL); +} + +void vkb_dec_VkPipelineCacheCreateInfo(vkb_dec *d, VkPipelineCacheCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineCacheCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkb_enc *e, const VkPipelineColorBlendAdvancedStateCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkb_enc *e, const VkPipelineColorBlendAdvancedStateCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineColorBlendAdvancedStateCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkb_dec *d, VkPipelineColorBlendAdvancedStateCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkb_dec *d, VkPipelineColorBlendAdvancedStateCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineColorBlendAdvancedStateCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineColorBlendStateCreateInfo(vkb_enc *e, const VkPipelineColorBlendStateCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pAttachments) { + uint32_t n_ = (uint32_t)(s->attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pAttachments, (size_t)n_ * sizeof(*s->pAttachments)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineColorBlendStateCreateInfo(vkb_enc *e, const VkPipelineColorBlendStateCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineColorBlendStateCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineColorBlendStateCreateInfo(vkb_dec *d, VkPipelineColorBlendStateCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pAttachments = (const VkPipelineColorBlendAttachmentState *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkPipelineColorBlendAttachmentState)); + } else { + s->pAttachments = NULL; + } +} + +void vkb_dec_VkPipelineColorBlendStateCreateInfo(vkb_dec *d, VkPipelineColorBlendStateCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineColorBlendStateCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineColorWriteCreateInfoEXT(vkb_enc *e, const VkPipelineColorWriteCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pColorWriteEnables) { + uint32_t n_ = (uint32_t)(s->attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pColorWriteEnables, (size_t)n_ * sizeof(*s->pColorWriteEnables)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineColorWriteCreateInfoEXT(vkb_enc *e, const VkPipelineColorWriteCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineColorWriteCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineColorWriteCreateInfoEXT(vkb_dec *d, VkPipelineColorWriteCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pColorWriteEnables = (const VkBool32 *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBool32)); + } else { + s->pColorWriteEnables = NULL; + } +} + +void vkb_dec_VkPipelineColorWriteCreateInfoEXT(vkb_dec *d, VkPipelineColorWriteCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineColorWriteCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineCreationFeedbackCreateInfo(vkb_enc *e, const VkPipelineCreationFeedbackCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pPipelineCreationFeedback) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pPipelineCreationFeedback, (size_t)n_ * sizeof(*s->pPipelineCreationFeedback)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pPipelineStageCreationFeedbacks) { + uint32_t n_ = (uint32_t)(s->pipelineStageCreationFeedbackCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pPipelineStageCreationFeedbacks, (size_t)n_ * sizeof(*s->pPipelineStageCreationFeedbacks)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineCreationFeedbackCreateInfo(vkb_enc *e, const VkPipelineCreationFeedbackCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineCreationFeedbackCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineCreationFeedbackCreateInfo(vkb_dec *d, VkPipelineCreationFeedbackCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pPipelineCreationFeedback = (VkPipelineCreationFeedback *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkPipelineCreationFeedback)); + } else { + s->pPipelineCreationFeedback = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pPipelineStageCreationFeedbacks = (VkPipelineCreationFeedback *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkPipelineCreationFeedback)); + } else { + s->pPipelineStageCreationFeedbacks = NULL; + } +} + +void vkb_dec_VkPipelineCreationFeedbackCreateInfo(vkb_dec *d, VkPipelineCreationFeedbackCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineCreationFeedbackCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineDepthStencilStateCreateInfo(vkb_enc *e, const VkPipelineDepthStencilStateCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineDepthStencilStateCreateInfo(vkb_enc *e, const VkPipelineDepthStencilStateCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineDepthStencilStateCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineDepthStencilStateCreateInfo(vkb_dec *d, VkPipelineDepthStencilStateCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineDepthStencilStateCreateInfo(vkb_dec *d, VkPipelineDepthStencilStateCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineDepthStencilStateCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineDiscardRectangleStateCreateInfoEXT(vkb_enc *e, const VkPipelineDiscardRectangleStateCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pDiscardRectangles) { + uint32_t n_ = (uint32_t)(s->discardRectangleCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDiscardRectangles, (size_t)n_ * sizeof(*s->pDiscardRectangles)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineDiscardRectangleStateCreateInfoEXT(vkb_enc *e, const VkPipelineDiscardRectangleStateCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineDiscardRectangleStateCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineDiscardRectangleStateCreateInfoEXT(vkb_dec *d, VkPipelineDiscardRectangleStateCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDiscardRectangles = (const VkRect2D *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkRect2D)); + } else { + s->pDiscardRectangles = NULL; + } +} + +void vkb_dec_VkPipelineDiscardRectangleStateCreateInfoEXT(vkb_dec *d, VkPipelineDiscardRectangleStateCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineDiscardRectangleStateCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineDynamicStateCreateInfo(vkb_enc *e, const VkPipelineDynamicStateCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pDynamicStates) { + uint32_t n_ = (uint32_t)(s->dynamicStateCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDynamicStates, (size_t)n_ * sizeof(*s->pDynamicStates)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineDynamicStateCreateInfo(vkb_enc *e, const VkPipelineDynamicStateCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineDynamicStateCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineDynamicStateCreateInfo(vkb_dec *d, VkPipelineDynamicStateCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDynamicStates = (const VkDynamicState *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDynamicState)); + } else { + s->pDynamicStates = NULL; + } +} + +void vkb_dec_VkPipelineDynamicStateCreateInfo(vkb_dec *d, VkPipelineDynamicStateCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineDynamicStateCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkb_enc *e, const VkPipelineFragmentShadingRateStateCreateInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkb_enc *e, const VkPipelineFragmentShadingRateStateCreateInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineFragmentShadingRateStateCreateInfoKHR(e, s, raw); +} + +void vkb_decfix_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkb_dec *d, VkPipelineFragmentShadingRateStateCreateInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkb_dec *d, VkPipelineFragmentShadingRateStateCreateInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineFragmentShadingRateStateCreateInfoKHR(d, s); +} + +void vkb_encfix_VkPipelineInputAssemblyStateCreateInfo(vkb_enc *e, const VkPipelineInputAssemblyStateCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineInputAssemblyStateCreateInfo(vkb_enc *e, const VkPipelineInputAssemblyStateCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineInputAssemblyStateCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineInputAssemblyStateCreateInfo(vkb_dec *d, VkPipelineInputAssemblyStateCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineInputAssemblyStateCreateInfo(vkb_dec *d, VkPipelineInputAssemblyStateCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineInputAssemblyStateCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineLayoutCreateInfo(vkb_enc *e, const VkPipelineLayoutCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pSetLayouts) { + uint32_t n_ = (uint32_t)(s->setLayoutCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pSetLayouts, (size_t)n_ * sizeof(*s->pSetLayouts)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pPushConstantRanges) { + uint32_t n_ = (uint32_t)(s->pushConstantRangeCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pPushConstantRanges, (size_t)n_ * sizeof(*s->pPushConstantRanges)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineLayoutCreateInfo(vkb_enc *e, const VkPipelineLayoutCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineLayoutCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineLayoutCreateInfo(vkb_dec *d, VkPipelineLayoutCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pSetLayouts = (const VkDescriptorSetLayout *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDescriptorSetLayout)); + } else { + s->pSetLayouts = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pPushConstantRanges = (const VkPushConstantRange *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkPushConstantRange)); + } else { + s->pPushConstantRanges = NULL; + } +} + +void vkb_dec_VkPipelineLayoutCreateInfo(vkb_dec *d, VkPipelineLayoutCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineLayoutCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineLibraryCreateInfoKHR(vkb_enc *e, const VkPipelineLibraryCreateInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pLibraries) { + uint32_t n_ = (uint32_t)(s->libraryCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pLibraries, (size_t)n_ * sizeof(*s->pLibraries)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineLibraryCreateInfoKHR(vkb_enc *e, const VkPipelineLibraryCreateInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineLibraryCreateInfoKHR(e, s, raw); +} + +void vkb_decfix_VkPipelineLibraryCreateInfoKHR(vkb_dec *d, VkPipelineLibraryCreateInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pLibraries = (const VkPipeline *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkPipeline)); + } else { + s->pLibraries = NULL; + } +} + +void vkb_dec_VkPipelineLibraryCreateInfoKHR(vkb_dec *d, VkPipelineLibraryCreateInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineLibraryCreateInfoKHR(d, s); +} + +void vkb_encfix_VkPipelineMultisampleStateCreateInfo(vkb_enc *e, const VkPipelineMultisampleStateCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pSampleMask) { + uint32_t n_ = (uint32_t)((((uint32_t)s->rasterizationSamples + 31) / 32)); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pSampleMask, (size_t)n_ * sizeof(*s->pSampleMask)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineMultisampleStateCreateInfo(vkb_enc *e, const VkPipelineMultisampleStateCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineMultisampleStateCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineMultisampleStateCreateInfo(vkb_dec *d, VkPipelineMultisampleStateCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pSampleMask = (const VkSampleMask *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSampleMask)); + } else { + s->pSampleMask = NULL; + } +} + +void vkb_dec_VkPipelineMultisampleStateCreateInfo(vkb_dec *d, VkPipelineMultisampleStateCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineMultisampleStateCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationConservativeStateCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationConservativeStateCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineRasterizationConservativeStateCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationConservativeStateCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationConservativeStateCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineRasterizationConservativeStateCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineRasterizationDepthClipStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationDepthClipStateCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineRasterizationDepthClipStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationDepthClipStateCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineRasterizationDepthClipStateCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineRasterizationDepthClipStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationDepthClipStateCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineRasterizationDepthClipStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationDepthClipStateCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineRasterizationDepthClipStateCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineRasterizationLineStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationLineStateCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineRasterizationLineStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationLineStateCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineRasterizationLineStateCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineRasterizationLineStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationLineStateCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineRasterizationLineStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationLineStateCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineRasterizationLineStateCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineRasterizationStateCreateInfo(vkb_enc *e, const VkPipelineRasterizationStateCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineRasterizationStateCreateInfo(vkb_enc *e, const VkPipelineRasterizationStateCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineRasterizationStateCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineRasterizationStateCreateInfo(vkb_dec *d, VkPipelineRasterizationStateCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineRasterizationStateCreateInfo(vkb_dec *d, VkPipelineRasterizationStateCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineRasterizationStateCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineRasterizationStateStreamCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationStateStreamCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineRasterizationStateStreamCreateInfoEXT(vkb_enc *e, const VkPipelineRasterizationStateStreamCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineRasterizationStateStreamCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineRasterizationStateStreamCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationStateStreamCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineRasterizationStateStreamCreateInfoEXT(vkb_dec *d, VkPipelineRasterizationStateStreamCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineRasterizationStateStreamCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineRenderingCreateInfo(vkb_enc *e, const VkPipelineRenderingCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pColorAttachmentFormats) { + uint32_t n_ = (uint32_t)(s->colorAttachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pColorAttachmentFormats, (size_t)n_ * sizeof(*s->pColorAttachmentFormats)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineRenderingCreateInfo(vkb_enc *e, const VkPipelineRenderingCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineRenderingCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineRenderingCreateInfo(vkb_dec *d, VkPipelineRenderingCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pColorAttachmentFormats = (const VkFormat *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkFormat)); + } else { + s->pColorAttachmentFormats = NULL; + } +} + +void vkb_dec_VkPipelineRenderingCreateInfo(vkb_dec *d, VkPipelineRenderingCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineRenderingCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineRobustnessCreateInfoEXT(vkb_enc *e, const VkPipelineRobustnessCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineRobustnessCreateInfoEXT(vkb_enc *e, const VkPipelineRobustnessCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineRobustnessCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineRobustnessCreateInfoEXT(vkb_dec *d, VkPipelineRobustnessCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineRobustnessCreateInfoEXT(vkb_dec *d, VkPipelineRobustnessCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineRobustnessCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineSampleLocationsStateCreateInfoEXT(vkb_enc *e, const VkPipelineSampleLocationsStateCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_encfix_VkSampleLocationsInfoEXT(e, &s->sampleLocationsInfo, raw + offsetof(VkPipelineSampleLocationsStateCreateInfoEXT, sampleLocationsInfo)); +} + +void vkb_enc_VkPipelineSampleLocationsStateCreateInfoEXT(vkb_enc *e, const VkPipelineSampleLocationsStateCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineSampleLocationsStateCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineSampleLocationsStateCreateInfoEXT(vkb_dec *d, VkPipelineSampleLocationsStateCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + vkb_decfix_VkSampleLocationsInfoEXT(d, &s->sampleLocationsInfo); +} + +void vkb_dec_VkPipelineSampleLocationsStateCreateInfoEXT(vkb_dec *d, VkPipelineSampleLocationsStateCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineSampleLocationsStateCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineShaderStageCreateInfo(vkb_enc *e, const VkPipelineShaderStageCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_enc_str(e, s->pName ? s->pName : NULL); + if (s->pSpecializationInfo) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSpecializationInfo(e, &s->pSpecializationInfo[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineShaderStageCreateInfo(vkb_enc *e, const VkPipelineShaderStageCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineShaderStageCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineShaderStageCreateInfo(vkb_dec *d, VkPipelineShaderStageCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + s->pName = vkb_dec_str(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSpecializationInfo *a_ = (VkSpecializationInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSpecializationInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSpecializationInfo(d, &a_[i_]); + s->pSpecializationInfo = a_; + } else { + s->pSpecializationInfo = NULL; + } +} + +void vkb_dec_VkPipelineShaderStageCreateInfo(vkb_dec *d, VkPipelineShaderStageCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineShaderStageCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(vkb_enc *e, const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pIdentifier) { + uint32_t n_ = (uint32_t)(s->identifierSize); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pIdentifier, (size_t)n_ * sizeof(*s->pIdentifier)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(vkb_enc *e, const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(vkb_dec *d, VkPipelineShaderStageModuleIdentifierCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pIdentifier = (const uint8_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint8_t)); + } else { + s->pIdentifier = NULL; + } +} + +void vkb_dec_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(vkb_dec *d, VkPipelineShaderStageModuleIdentifierCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(vkb_enc *e, const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(vkb_enc *e, const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(vkb_dec *d, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(vkb_dec *d, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineTessellationDomainOriginStateCreateInfo(vkb_enc *e, const VkPipelineTessellationDomainOriginStateCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineTessellationDomainOriginStateCreateInfo(vkb_enc *e, const VkPipelineTessellationDomainOriginStateCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineTessellationDomainOriginStateCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineTessellationDomainOriginStateCreateInfo(vkb_dec *d, VkPipelineTessellationDomainOriginStateCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineTessellationDomainOriginStateCreateInfo(vkb_dec *d, VkPipelineTessellationDomainOriginStateCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineTessellationDomainOriginStateCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineTessellationStateCreateInfo(vkb_enc *e, const VkPipelineTessellationStateCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineTessellationStateCreateInfo(vkb_enc *e, const VkPipelineTessellationStateCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineTessellationStateCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineTessellationStateCreateInfo(vkb_dec *d, VkPipelineTessellationStateCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineTessellationStateCreateInfo(vkb_dec *d, VkPipelineTessellationStateCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineTessellationStateCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkb_enc *e, const VkPipelineVertexInputDivisorStateCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pVertexBindingDivisors) { + uint32_t n_ = (uint32_t)(s->vertexBindingDivisorCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pVertexBindingDivisors, (size_t)n_ * sizeof(*s->pVertexBindingDivisors)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkb_enc *e, const VkPipelineVertexInputDivisorStateCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineVertexInputDivisorStateCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkb_dec *d, VkPipelineVertexInputDivisorStateCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pVertexBindingDivisors = (const VkVertexInputBindingDivisorDescriptionEXT *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkVertexInputBindingDivisorDescriptionEXT)); + } else { + s->pVertexBindingDivisors = NULL; + } +} + +void vkb_dec_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkb_dec *d, VkPipelineVertexInputDivisorStateCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineVertexInputDivisorStateCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineVertexInputStateCreateInfo(vkb_enc *e, const VkPipelineVertexInputStateCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pVertexBindingDescriptions) { + uint32_t n_ = (uint32_t)(s->vertexBindingDescriptionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pVertexBindingDescriptions, (size_t)n_ * sizeof(*s->pVertexBindingDescriptions)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pVertexAttributeDescriptions) { + uint32_t n_ = (uint32_t)(s->vertexAttributeDescriptionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pVertexAttributeDescriptions, (size_t)n_ * sizeof(*s->pVertexAttributeDescriptions)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineVertexInputStateCreateInfo(vkb_enc *e, const VkPipelineVertexInputStateCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineVertexInputStateCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineVertexInputStateCreateInfo(vkb_dec *d, VkPipelineVertexInputStateCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pVertexBindingDescriptions = (const VkVertexInputBindingDescription *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkVertexInputBindingDescription)); + } else { + s->pVertexBindingDescriptions = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pVertexAttributeDescriptions = (const VkVertexInputAttributeDescription *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkVertexInputAttributeDescription)); + } else { + s->pVertexAttributeDescriptions = NULL; + } +} + +void vkb_dec_VkPipelineVertexInputStateCreateInfo(vkb_dec *d, VkPipelineVertexInputStateCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineVertexInputStateCreateInfo(d, s); +} + +void vkb_encfix_VkPipelineViewportDepthClipControlCreateInfoEXT(vkb_enc *e, const VkPipelineViewportDepthClipControlCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkPipelineViewportDepthClipControlCreateInfoEXT(vkb_enc *e, const VkPipelineViewportDepthClipControlCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineViewportDepthClipControlCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkPipelineViewportDepthClipControlCreateInfoEXT(vkb_dec *d, VkPipelineViewportDepthClipControlCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkPipelineViewportDepthClipControlCreateInfoEXT(vkb_dec *d, VkPipelineViewportDepthClipControlCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineViewportDepthClipControlCreateInfoEXT(d, s); +} + +void vkb_encfix_VkPipelineViewportStateCreateInfo(vkb_enc *e, const VkPipelineViewportStateCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pViewports) { + uint32_t n_ = (uint32_t)(s->viewportCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pViewports, (size_t)n_ * sizeof(*s->pViewports)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pScissors) { + uint32_t n_ = (uint32_t)(s->scissorCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pScissors, (size_t)n_ * sizeof(*s->pScissors)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkPipelineViewportStateCreateInfo(vkb_enc *e, const VkPipelineViewportStateCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkPipelineViewportStateCreateInfo(e, s, raw); +} + +void vkb_decfix_VkPipelineViewportStateCreateInfo(vkb_dec *d, VkPipelineViewportStateCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pViewports = (const VkViewport *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkViewport)); + } else { + s->pViewports = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pScissors = (const VkRect2D *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkRect2D)); + } else { + s->pScissors = NULL; + } +} + +void vkb_dec_VkPipelineViewportStateCreateInfo(vkb_dec *d, VkPipelineViewportStateCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkPipelineViewportStateCreateInfo(d, s); +} + +void vkb_encfix_VkProtectedSubmitInfo(vkb_enc *e, const VkProtectedSubmitInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkProtectedSubmitInfo(vkb_enc *e, const VkProtectedSubmitInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkProtectedSubmitInfo(e, s, raw); +} + +void vkb_decfix_VkProtectedSubmitInfo(vkb_dec *d, VkProtectedSubmitInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkProtectedSubmitInfo(vkb_dec *d, VkProtectedSubmitInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkProtectedSubmitInfo(d, s); +} + +void vkb_encfix_VkQueryPoolCreateInfo(vkb_enc *e, const VkQueryPoolCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkQueryPoolCreateInfo(vkb_enc *e, const VkQueryPoolCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkQueryPoolCreateInfo(e, s, raw); +} + +void vkb_decfix_VkQueryPoolCreateInfo(vkb_dec *d, VkQueryPoolCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkQueryPoolCreateInfo(vkb_dec *d, VkQueryPoolCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkQueryPoolCreateInfo(d, s); +} + +void vkb_encfix_VkQueueFamilyGlobalPriorityPropertiesKHR(vkb_enc *e, const VkQueueFamilyGlobalPriorityPropertiesKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkQueueFamilyGlobalPriorityPropertiesKHR(vkb_enc *e, const VkQueueFamilyGlobalPriorityPropertiesKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkQueueFamilyGlobalPriorityPropertiesKHR(e, s, raw); +} + +void vkb_decfix_VkQueueFamilyGlobalPriorityPropertiesKHR(vkb_dec *d, VkQueueFamilyGlobalPriorityPropertiesKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkQueueFamilyGlobalPriorityPropertiesKHR(vkb_dec *d, VkQueueFamilyGlobalPriorityPropertiesKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkQueueFamilyGlobalPriorityPropertiesKHR(d, s); +} + +void vkb_encfix_VkQueueFamilyProperties2(vkb_enc *e, const VkQueueFamilyProperties2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkQueueFamilyProperties2(vkb_enc *e, const VkQueueFamilyProperties2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkQueueFamilyProperties2(e, s, raw); +} + +void vkb_decfix_VkQueueFamilyProperties2(vkb_dec *d, VkQueueFamilyProperties2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkQueueFamilyProperties2(vkb_dec *d, VkQueueFamilyProperties2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkQueueFamilyProperties2(d, s); +} + +void vkb_encfix_VkRenderPassAttachmentBeginInfo(vkb_enc *e, const VkRenderPassAttachmentBeginInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pAttachments) { + uint32_t n_ = (uint32_t)(s->attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pAttachments, (size_t)n_ * sizeof(*s->pAttachments)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkRenderPassAttachmentBeginInfo(vkb_enc *e, const VkRenderPassAttachmentBeginInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderPassAttachmentBeginInfo(e, s, raw); +} + +void vkb_decfix_VkRenderPassAttachmentBeginInfo(vkb_dec *d, VkRenderPassAttachmentBeginInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pAttachments = (const VkImageView *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkImageView)); + } else { + s->pAttachments = NULL; + } +} + +void vkb_dec_VkRenderPassAttachmentBeginInfo(vkb_dec *d, VkRenderPassAttachmentBeginInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderPassAttachmentBeginInfo(d, s); +} + +void vkb_encfix_VkRenderPassBeginInfo(vkb_enc *e, const VkRenderPassBeginInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pClearValues) { + uint32_t n_ = (uint32_t)(s->clearValueCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pClearValues, (size_t)n_ * sizeof(*s->pClearValues)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkRenderPassBeginInfo(vkb_enc *e, const VkRenderPassBeginInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderPassBeginInfo(e, s, raw); +} + +void vkb_decfix_VkRenderPassBeginInfo(vkb_dec *d, VkRenderPassBeginInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pClearValues = (const VkClearValue *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkClearValue)); + } else { + s->pClearValues = NULL; + } +} + +void vkb_dec_VkRenderPassBeginInfo(vkb_dec *d, VkRenderPassBeginInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderPassBeginInfo(d, s); +} + +void vkb_encfix_VkRenderPassCreateInfo(vkb_enc *e, const VkRenderPassCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pAttachments) { + uint32_t n_ = (uint32_t)(s->attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pAttachments, (size_t)n_ * sizeof(*s->pAttachments)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pSubpasses) { + uint32_t n_ = (uint32_t)(s->subpassCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSubpassDescription(e, &s->pSubpasses[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pDependencies) { + uint32_t n_ = (uint32_t)(s->dependencyCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDependencies, (size_t)n_ * sizeof(*s->pDependencies)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkRenderPassCreateInfo(vkb_enc *e, const VkRenderPassCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderPassCreateInfo(e, s, raw); +} + +void vkb_decfix_VkRenderPassCreateInfo(vkb_dec *d, VkRenderPassCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pAttachments = (const VkAttachmentDescription *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkAttachmentDescription)); + } else { + s->pAttachments = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSubpassDescription *a_ = (VkSubpassDescription *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSubpassDescription)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSubpassDescription(d, &a_[i_]); + s->pSubpasses = a_; + } else { + s->pSubpasses = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDependencies = (const VkSubpassDependency *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSubpassDependency)); + } else { + s->pDependencies = NULL; + } +} + +void vkb_dec_VkRenderPassCreateInfo(vkb_dec *d, VkRenderPassCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderPassCreateInfo(d, s); +} + +void vkb_encfix_VkRenderPassCreateInfo2(vkb_enc *e, const VkRenderPassCreateInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pAttachments) { + uint32_t n_ = (uint32_t)(s->attachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkAttachmentDescription2(e, &s->pAttachments[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pSubpasses) { + uint32_t n_ = (uint32_t)(s->subpassCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSubpassDescription2(e, &s->pSubpasses[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pDependencies) { + uint32_t n_ = (uint32_t)(s->dependencyCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSubpassDependency2(e, &s->pDependencies[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pCorrelatedViewMasks) { + uint32_t n_ = (uint32_t)(s->correlatedViewMaskCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pCorrelatedViewMasks, (size_t)n_ * sizeof(*s->pCorrelatedViewMasks)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkRenderPassCreateInfo2(vkb_enc *e, const VkRenderPassCreateInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderPassCreateInfo2(e, s, raw); +} + +void vkb_decfix_VkRenderPassCreateInfo2(vkb_dec *d, VkRenderPassCreateInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkAttachmentDescription2 *a_ = (VkAttachmentDescription2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkAttachmentDescription2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkAttachmentDescription2(d, &a_[i_]); + s->pAttachments = a_; + } else { + s->pAttachments = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSubpassDescription2 *a_ = (VkSubpassDescription2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSubpassDescription2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSubpassDescription2(d, &a_[i_]); + s->pSubpasses = a_; + } else { + s->pSubpasses = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSubpassDependency2 *a_ = (VkSubpassDependency2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSubpassDependency2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSubpassDependency2(d, &a_[i_]); + s->pDependencies = a_; + } else { + s->pDependencies = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pCorrelatedViewMasks = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pCorrelatedViewMasks = NULL; + } +} + +void vkb_dec_VkRenderPassCreateInfo2(vkb_dec *d, VkRenderPassCreateInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderPassCreateInfo2(d, s); +} + +void vkb_encfix_VkRenderPassCreationControlEXT(vkb_enc *e, const VkRenderPassCreationControlEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkRenderPassCreationControlEXT(vkb_enc *e, const VkRenderPassCreationControlEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderPassCreationControlEXT(e, s, raw); +} + +void vkb_decfix_VkRenderPassCreationControlEXT(vkb_dec *d, VkRenderPassCreationControlEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkRenderPassCreationControlEXT(vkb_dec *d, VkRenderPassCreationControlEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderPassCreationControlEXT(d, s); +} + +void vkb_encfix_VkRenderPassCreationFeedbackCreateInfoEXT(vkb_enc *e, const VkRenderPassCreationFeedbackCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pRenderPassFeedback) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pRenderPassFeedback, (size_t)n_ * sizeof(*s->pRenderPassFeedback)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkRenderPassCreationFeedbackCreateInfoEXT(vkb_enc *e, const VkRenderPassCreationFeedbackCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderPassCreationFeedbackCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkRenderPassCreationFeedbackCreateInfoEXT(vkb_dec *d, VkRenderPassCreationFeedbackCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pRenderPassFeedback = (VkRenderPassCreationFeedbackInfoEXT *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkRenderPassCreationFeedbackInfoEXT)); + } else { + s->pRenderPassFeedback = NULL; + } +} + +void vkb_dec_VkRenderPassCreationFeedbackCreateInfoEXT(vkb_dec *d, VkRenderPassCreationFeedbackCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderPassCreationFeedbackCreateInfoEXT(d, s); +} + +void vkb_encfix_VkRenderPassFragmentDensityMapCreateInfoEXT(vkb_enc *e, const VkRenderPassFragmentDensityMapCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkRenderPassFragmentDensityMapCreateInfoEXT(vkb_enc *e, const VkRenderPassFragmentDensityMapCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderPassFragmentDensityMapCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkRenderPassFragmentDensityMapCreateInfoEXT(vkb_dec *d, VkRenderPassFragmentDensityMapCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkRenderPassFragmentDensityMapCreateInfoEXT(vkb_dec *d, VkRenderPassFragmentDensityMapCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderPassFragmentDensityMapCreateInfoEXT(d, s); +} + +void vkb_encfix_VkRenderPassInputAttachmentAspectCreateInfo(vkb_enc *e, const VkRenderPassInputAttachmentAspectCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pAspectReferences) { + uint32_t n_ = (uint32_t)(s->aspectReferenceCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pAspectReferences, (size_t)n_ * sizeof(*s->pAspectReferences)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkRenderPassInputAttachmentAspectCreateInfo(vkb_enc *e, const VkRenderPassInputAttachmentAspectCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderPassInputAttachmentAspectCreateInfo(e, s, raw); +} + +void vkb_decfix_VkRenderPassInputAttachmentAspectCreateInfo(vkb_dec *d, VkRenderPassInputAttachmentAspectCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pAspectReferences = (const VkInputAttachmentAspectReference *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkInputAttachmentAspectReference)); + } else { + s->pAspectReferences = NULL; + } +} + +void vkb_dec_VkRenderPassInputAttachmentAspectCreateInfo(vkb_dec *d, VkRenderPassInputAttachmentAspectCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderPassInputAttachmentAspectCreateInfo(d, s); +} + +void vkb_encfix_VkRenderPassMultiviewCreateInfo(vkb_enc *e, const VkRenderPassMultiviewCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pViewMasks) { + uint32_t n_ = (uint32_t)(s->subpassCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pViewMasks, (size_t)n_ * sizeof(*s->pViewMasks)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pViewOffsets) { + uint32_t n_ = (uint32_t)(s->dependencyCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pViewOffsets, (size_t)n_ * sizeof(*s->pViewOffsets)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pCorrelationMasks) { + uint32_t n_ = (uint32_t)(s->correlationMaskCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pCorrelationMasks, (size_t)n_ * sizeof(*s->pCorrelationMasks)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkRenderPassMultiviewCreateInfo(vkb_enc *e, const VkRenderPassMultiviewCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderPassMultiviewCreateInfo(e, s, raw); +} + +void vkb_decfix_VkRenderPassMultiviewCreateInfo(vkb_dec *d, VkRenderPassMultiviewCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pViewMasks = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pViewMasks = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pViewOffsets = (const int32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(int32_t)); + } else { + s->pViewOffsets = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pCorrelationMasks = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pCorrelationMasks = NULL; + } +} + +void vkb_dec_VkRenderPassMultiviewCreateInfo(vkb_dec *d, VkRenderPassMultiviewCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderPassMultiviewCreateInfo(d, s); +} + +void vkb_encfix_VkRenderPassSampleLocationsBeginInfoEXT(vkb_enc *e, const VkRenderPassSampleLocationsBeginInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pAttachmentInitialSampleLocations) { + uint32_t n_ = (uint32_t)(s->attachmentInitialSampleLocationsCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkAttachmentSampleLocationsEXT(e, &s->pAttachmentInitialSampleLocations[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pPostSubpassSampleLocations) { + uint32_t n_ = (uint32_t)(s->postSubpassSampleLocationsCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSubpassSampleLocationsEXT(e, &s->pPostSubpassSampleLocations[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkRenderPassSampleLocationsBeginInfoEXT(vkb_enc *e, const VkRenderPassSampleLocationsBeginInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderPassSampleLocationsBeginInfoEXT(e, s, raw); +} + +void vkb_decfix_VkRenderPassSampleLocationsBeginInfoEXT(vkb_dec *d, VkRenderPassSampleLocationsBeginInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkAttachmentSampleLocationsEXT *a_ = (VkAttachmentSampleLocationsEXT *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkAttachmentSampleLocationsEXT)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkAttachmentSampleLocationsEXT(d, &a_[i_]); + s->pAttachmentInitialSampleLocations = a_; + } else { + s->pAttachmentInitialSampleLocations = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSubpassSampleLocationsEXT *a_ = (VkSubpassSampleLocationsEXT *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSubpassSampleLocationsEXT)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSubpassSampleLocationsEXT(d, &a_[i_]); + s->pPostSubpassSampleLocations = a_; + } else { + s->pPostSubpassSampleLocations = NULL; + } +} + +void vkb_dec_VkRenderPassSampleLocationsBeginInfoEXT(vkb_dec *d, VkRenderPassSampleLocationsBeginInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderPassSampleLocationsBeginInfoEXT(d, s); +} + +void vkb_encfix_VkRenderPassSubpassFeedbackCreateInfoEXT(vkb_enc *e, const VkRenderPassSubpassFeedbackCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pSubpassFeedback) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pSubpassFeedback, (size_t)n_ * sizeof(*s->pSubpassFeedback)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkRenderPassSubpassFeedbackCreateInfoEXT(vkb_enc *e, const VkRenderPassSubpassFeedbackCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderPassSubpassFeedbackCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkRenderPassSubpassFeedbackCreateInfoEXT(vkb_dec *d, VkRenderPassSubpassFeedbackCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pSubpassFeedback = (VkRenderPassSubpassFeedbackInfoEXT *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkRenderPassSubpassFeedbackInfoEXT)); + } else { + s->pSubpassFeedback = NULL; + } +} + +void vkb_dec_VkRenderPassSubpassFeedbackCreateInfoEXT(vkb_dec *d, VkRenderPassSubpassFeedbackCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderPassSubpassFeedbackCreateInfoEXT(d, s); +} + +void vkb_encfix_VkRenderingAttachmentInfo(vkb_enc *e, const VkRenderingAttachmentInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkRenderingAttachmentInfo(vkb_enc *e, const VkRenderingAttachmentInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderingAttachmentInfo(e, s, raw); +} + +void vkb_decfix_VkRenderingAttachmentInfo(vkb_dec *d, VkRenderingAttachmentInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkRenderingAttachmentInfo(vkb_dec *d, VkRenderingAttachmentInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderingAttachmentInfo(d, s); +} + +void vkb_encfix_VkRenderingFragmentDensityMapAttachmentInfoEXT(vkb_enc *e, const VkRenderingFragmentDensityMapAttachmentInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkRenderingFragmentDensityMapAttachmentInfoEXT(vkb_enc *e, const VkRenderingFragmentDensityMapAttachmentInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderingFragmentDensityMapAttachmentInfoEXT(e, s, raw); +} + +void vkb_decfix_VkRenderingFragmentDensityMapAttachmentInfoEXT(vkb_dec *d, VkRenderingFragmentDensityMapAttachmentInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkRenderingFragmentDensityMapAttachmentInfoEXT(vkb_dec *d, VkRenderingFragmentDensityMapAttachmentInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderingFragmentDensityMapAttachmentInfoEXT(d, s); +} + +void vkb_encfix_VkRenderingFragmentShadingRateAttachmentInfoKHR(vkb_enc *e, const VkRenderingFragmentShadingRateAttachmentInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkRenderingFragmentShadingRateAttachmentInfoKHR(vkb_enc *e, const VkRenderingFragmentShadingRateAttachmentInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderingFragmentShadingRateAttachmentInfoKHR(e, s, raw); +} + +void vkb_decfix_VkRenderingFragmentShadingRateAttachmentInfoKHR(vkb_dec *d, VkRenderingFragmentShadingRateAttachmentInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkRenderingFragmentShadingRateAttachmentInfoKHR(vkb_dec *d, VkRenderingFragmentShadingRateAttachmentInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderingFragmentShadingRateAttachmentInfoKHR(d, s); +} + +void vkb_encfix_VkRenderingInfo(vkb_enc *e, const VkRenderingInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pColorAttachments) { + uint32_t n_ = (uint32_t)(s->colorAttachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkRenderingAttachmentInfo(e, &s->pColorAttachments[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pDepthAttachment) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkRenderingAttachmentInfo(e, &s->pDepthAttachment[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pStencilAttachment) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkRenderingAttachmentInfo(e, &s->pStencilAttachment[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkRenderingInfo(vkb_enc *e, const VkRenderingInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkRenderingInfo(e, s, raw); +} + +void vkb_decfix_VkRenderingInfo(vkb_dec *d, VkRenderingInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkRenderingAttachmentInfo *a_ = (VkRenderingAttachmentInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkRenderingAttachmentInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkRenderingAttachmentInfo(d, &a_[i_]); + s->pColorAttachments = a_; + } else { + s->pColorAttachments = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkRenderingAttachmentInfo *a_ = (VkRenderingAttachmentInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkRenderingAttachmentInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkRenderingAttachmentInfo(d, &a_[i_]); + s->pDepthAttachment = a_; + } else { + s->pDepthAttachment = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkRenderingAttachmentInfo *a_ = (VkRenderingAttachmentInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkRenderingAttachmentInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkRenderingAttachmentInfo(d, &a_[i_]); + s->pStencilAttachment = a_; + } else { + s->pStencilAttachment = NULL; + } +} + +void vkb_dec_VkRenderingInfo(vkb_dec *d, VkRenderingInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkRenderingInfo(d, s); +} + +void vkb_encfix_VkResolveImageInfo2(vkb_enc *e, const VkResolveImageInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pRegions) { + uint32_t n_ = (uint32_t)(s->regionCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkImageResolve2(e, &s->pRegions[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkResolveImageInfo2(vkb_enc *e, const VkResolveImageInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkResolveImageInfo2(e, s, raw); +} + +void vkb_decfix_VkResolveImageInfo2(vkb_dec *d, VkResolveImageInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkImageResolve2 *a_ = (VkImageResolve2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkImageResolve2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkImageResolve2(d, &a_[i_]); + s->pRegions = a_; + } else { + s->pRegions = NULL; + } +} + +void vkb_dec_VkResolveImageInfo2(vkb_dec *d, VkResolveImageInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkResolveImageInfo2(d, s); +} + +void vkb_encfix_VkSampleLocationsInfoEXT(vkb_enc *e, const VkSampleLocationsInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pSampleLocations) { + uint32_t n_ = (uint32_t)(s->sampleLocationsCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pSampleLocations, (size_t)n_ * sizeof(*s->pSampleLocations)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkSampleLocationsInfoEXT(vkb_enc *e, const VkSampleLocationsInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSampleLocationsInfoEXT(e, s, raw); +} + +void vkb_decfix_VkSampleLocationsInfoEXT(vkb_dec *d, VkSampleLocationsInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pSampleLocations = (const VkSampleLocationEXT *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSampleLocationEXT)); + } else { + s->pSampleLocations = NULL; + } +} + +void vkb_dec_VkSampleLocationsInfoEXT(vkb_dec *d, VkSampleLocationsInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSampleLocationsInfoEXT(d, s); +} + +void vkb_encfix_VkSamplerBorderColorComponentMappingCreateInfoEXT(vkb_enc *e, const VkSamplerBorderColorComponentMappingCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSamplerBorderColorComponentMappingCreateInfoEXT(vkb_enc *e, const VkSamplerBorderColorComponentMappingCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSamplerBorderColorComponentMappingCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkSamplerBorderColorComponentMappingCreateInfoEXT(vkb_dec *d, VkSamplerBorderColorComponentMappingCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSamplerBorderColorComponentMappingCreateInfoEXT(vkb_dec *d, VkSamplerBorderColorComponentMappingCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSamplerBorderColorComponentMappingCreateInfoEXT(d, s); +} + +void vkb_encfix_VkSamplerCreateInfo(vkb_enc *e, const VkSamplerCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSamplerCreateInfo(vkb_enc *e, const VkSamplerCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSamplerCreateInfo(e, s, raw); +} + +void vkb_decfix_VkSamplerCreateInfo(vkb_dec *d, VkSamplerCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSamplerCreateInfo(vkb_dec *d, VkSamplerCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSamplerCreateInfo(d, s); +} + +void vkb_encfix_VkSamplerCustomBorderColorCreateInfoEXT(vkb_enc *e, const VkSamplerCustomBorderColorCreateInfoEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSamplerCustomBorderColorCreateInfoEXT(vkb_enc *e, const VkSamplerCustomBorderColorCreateInfoEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSamplerCustomBorderColorCreateInfoEXT(e, s, raw); +} + +void vkb_decfix_VkSamplerCustomBorderColorCreateInfoEXT(vkb_dec *d, VkSamplerCustomBorderColorCreateInfoEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSamplerCustomBorderColorCreateInfoEXT(vkb_dec *d, VkSamplerCustomBorderColorCreateInfoEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSamplerCustomBorderColorCreateInfoEXT(d, s); +} + +void vkb_encfix_VkSamplerReductionModeCreateInfo(vkb_enc *e, const VkSamplerReductionModeCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSamplerReductionModeCreateInfo(vkb_enc *e, const VkSamplerReductionModeCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSamplerReductionModeCreateInfo(e, s, raw); +} + +void vkb_decfix_VkSamplerReductionModeCreateInfo(vkb_dec *d, VkSamplerReductionModeCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSamplerReductionModeCreateInfo(vkb_dec *d, VkSamplerReductionModeCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSamplerReductionModeCreateInfo(d, s); +} + +void vkb_encfix_VkSamplerYcbcrConversionCreateInfo(vkb_enc *e, const VkSamplerYcbcrConversionCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSamplerYcbcrConversionCreateInfo(vkb_enc *e, const VkSamplerYcbcrConversionCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSamplerYcbcrConversionCreateInfo(e, s, raw); +} + +void vkb_decfix_VkSamplerYcbcrConversionCreateInfo(vkb_dec *d, VkSamplerYcbcrConversionCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSamplerYcbcrConversionCreateInfo(vkb_dec *d, VkSamplerYcbcrConversionCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSamplerYcbcrConversionCreateInfo(d, s); +} + +void vkb_encfix_VkSamplerYcbcrConversionImageFormatProperties(vkb_enc *e, const VkSamplerYcbcrConversionImageFormatProperties *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSamplerYcbcrConversionImageFormatProperties(vkb_enc *e, const VkSamplerYcbcrConversionImageFormatProperties *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSamplerYcbcrConversionImageFormatProperties(e, s, raw); +} + +void vkb_decfix_VkSamplerYcbcrConversionImageFormatProperties(vkb_dec *d, VkSamplerYcbcrConversionImageFormatProperties *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSamplerYcbcrConversionImageFormatProperties(vkb_dec *d, VkSamplerYcbcrConversionImageFormatProperties *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSamplerYcbcrConversionImageFormatProperties(d, s); +} + +void vkb_encfix_VkSamplerYcbcrConversionInfo(vkb_enc *e, const VkSamplerYcbcrConversionInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSamplerYcbcrConversionInfo(vkb_enc *e, const VkSamplerYcbcrConversionInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSamplerYcbcrConversionInfo(e, s, raw); +} + +void vkb_decfix_VkSamplerYcbcrConversionInfo(vkb_dec *d, VkSamplerYcbcrConversionInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSamplerYcbcrConversionInfo(vkb_dec *d, VkSamplerYcbcrConversionInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSamplerYcbcrConversionInfo(d, s); +} + +void vkb_encfix_VkSemaphoreCreateInfo(vkb_enc *e, const VkSemaphoreCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSemaphoreCreateInfo(vkb_enc *e, const VkSemaphoreCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSemaphoreCreateInfo(e, s, raw); +} + +void vkb_decfix_VkSemaphoreCreateInfo(vkb_dec *d, VkSemaphoreCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSemaphoreCreateInfo(vkb_dec *d, VkSemaphoreCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSemaphoreCreateInfo(d, s); +} + +void vkb_encfix_VkSemaphoreGetFdInfoKHR(vkb_enc *e, const VkSemaphoreGetFdInfoKHR *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSemaphoreGetFdInfoKHR(vkb_enc *e, const VkSemaphoreGetFdInfoKHR *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSemaphoreGetFdInfoKHR(e, s, raw); +} + +void vkb_decfix_VkSemaphoreGetFdInfoKHR(vkb_dec *d, VkSemaphoreGetFdInfoKHR *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSemaphoreGetFdInfoKHR(vkb_dec *d, VkSemaphoreGetFdInfoKHR *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSemaphoreGetFdInfoKHR(d, s); +} + +void vkb_encfix_VkSemaphoreSignalInfo(vkb_enc *e, const VkSemaphoreSignalInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSemaphoreSignalInfo(vkb_enc *e, const VkSemaphoreSignalInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSemaphoreSignalInfo(e, s, raw); +} + +void vkb_decfix_VkSemaphoreSignalInfo(vkb_dec *d, VkSemaphoreSignalInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSemaphoreSignalInfo(vkb_dec *d, VkSemaphoreSignalInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSemaphoreSignalInfo(d, s); +} + +void vkb_encfix_VkSemaphoreSubmitInfo(vkb_enc *e, const VkSemaphoreSubmitInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSemaphoreSubmitInfo(vkb_enc *e, const VkSemaphoreSubmitInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSemaphoreSubmitInfo(e, s, raw); +} + +void vkb_decfix_VkSemaphoreSubmitInfo(vkb_dec *d, VkSemaphoreSubmitInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSemaphoreSubmitInfo(vkb_dec *d, VkSemaphoreSubmitInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSemaphoreSubmitInfo(d, s); +} + +void vkb_encfix_VkSemaphoreTypeCreateInfo(vkb_enc *e, const VkSemaphoreTypeCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSemaphoreTypeCreateInfo(vkb_enc *e, const VkSemaphoreTypeCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSemaphoreTypeCreateInfo(e, s, raw); +} + +void vkb_decfix_VkSemaphoreTypeCreateInfo(vkb_dec *d, VkSemaphoreTypeCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSemaphoreTypeCreateInfo(vkb_dec *d, VkSemaphoreTypeCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSemaphoreTypeCreateInfo(d, s); +} + +void vkb_encfix_VkSemaphoreWaitInfo(vkb_enc *e, const VkSemaphoreWaitInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pSemaphores) { + uint32_t n_ = (uint32_t)(s->semaphoreCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pSemaphores, (size_t)n_ * sizeof(*s->pSemaphores)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pValues) { + uint32_t n_ = (uint32_t)(s->semaphoreCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pValues, (size_t)n_ * sizeof(*s->pValues)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkSemaphoreWaitInfo(vkb_enc *e, const VkSemaphoreWaitInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSemaphoreWaitInfo(e, s, raw); +} + +void vkb_decfix_VkSemaphoreWaitInfo(vkb_dec *d, VkSemaphoreWaitInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pSemaphores = (const VkSemaphore *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSemaphore)); + } else { + s->pSemaphores = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pValues = (const uint64_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint64_t)); + } else { + s->pValues = NULL; + } +} + +void vkb_dec_VkSemaphoreWaitInfo(vkb_dec *d, VkSemaphoreWaitInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSemaphoreWaitInfo(d, s); +} + +void vkb_encfix_VkShaderModuleCreateInfo(vkb_enc *e, const VkShaderModuleCreateInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_enc_blob(e, s->pCode ? (const void *)s->pCode : NULL, s->pCode ? (size_t)(s->codeSize) : 0); +} + +void vkb_enc_VkShaderModuleCreateInfo(vkb_enc *e, const VkShaderModuleCreateInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkShaderModuleCreateInfo(e, s, raw); +} + +void vkb_decfix_VkShaderModuleCreateInfo(vkb_dec *d, VkShaderModuleCreateInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + s->pCode = (const uint32_t *)vkb_dec_blob(d, NULL); +} + +void vkb_dec_VkShaderModuleCreateInfo(vkb_dec *d, VkShaderModuleCreateInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkShaderModuleCreateInfo(d, s); +} + +void vkb_encfix_VkShaderModuleIdentifierEXT(vkb_enc *e, const VkShaderModuleIdentifierEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkShaderModuleIdentifierEXT(vkb_enc *e, const VkShaderModuleIdentifierEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkShaderModuleIdentifierEXT(e, s, raw); +} + +void vkb_decfix_VkShaderModuleIdentifierEXT(vkb_dec *d, VkShaderModuleIdentifierEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkShaderModuleIdentifierEXT(vkb_dec *d, VkShaderModuleIdentifierEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkShaderModuleIdentifierEXT(d, s); +} + +void vkb_encfix_VkSparseBufferMemoryBindInfo(vkb_enc *e, const VkSparseBufferMemoryBindInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + if (s->pBinds) { + uint32_t n_ = (uint32_t)(s->bindCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pBinds, (size_t)n_ * sizeof(*s->pBinds)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkSparseBufferMemoryBindInfo(vkb_enc *e, const VkSparseBufferMemoryBindInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSparseBufferMemoryBindInfo(e, s, raw); +} + +void vkb_decfix_VkSparseBufferMemoryBindInfo(vkb_dec *d, VkSparseBufferMemoryBindInfo *s) +{ + (void)d; (void)s; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pBinds = (const VkSparseMemoryBind *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSparseMemoryBind)); + } else { + s->pBinds = NULL; + } +} + +void vkb_dec_VkSparseBufferMemoryBindInfo(vkb_dec *d, VkSparseBufferMemoryBindInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSparseBufferMemoryBindInfo(d, s); +} + +void vkb_encfix_VkSparseImageFormatProperties2(vkb_enc *e, const VkSparseImageFormatProperties2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSparseImageFormatProperties2(vkb_enc *e, const VkSparseImageFormatProperties2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSparseImageFormatProperties2(e, s, raw); +} + +void vkb_decfix_VkSparseImageFormatProperties2(vkb_dec *d, VkSparseImageFormatProperties2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSparseImageFormatProperties2(vkb_dec *d, VkSparseImageFormatProperties2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSparseImageFormatProperties2(d, s); +} + +void vkb_encfix_VkSparseImageMemoryBindInfo(vkb_enc *e, const VkSparseImageMemoryBindInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + if (s->pBinds) { + uint32_t n_ = (uint32_t)(s->bindCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pBinds, (size_t)n_ * sizeof(*s->pBinds)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkSparseImageMemoryBindInfo(vkb_enc *e, const VkSparseImageMemoryBindInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSparseImageMemoryBindInfo(e, s, raw); +} + +void vkb_decfix_VkSparseImageMemoryBindInfo(vkb_dec *d, VkSparseImageMemoryBindInfo *s) +{ + (void)d; (void)s; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pBinds = (const VkSparseImageMemoryBind *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSparseImageMemoryBind)); + } else { + s->pBinds = NULL; + } +} + +void vkb_dec_VkSparseImageMemoryBindInfo(vkb_dec *d, VkSparseImageMemoryBindInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSparseImageMemoryBindInfo(d, s); +} + +void vkb_encfix_VkSparseImageMemoryRequirements2(vkb_enc *e, const VkSparseImageMemoryRequirements2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSparseImageMemoryRequirements2(vkb_enc *e, const VkSparseImageMemoryRequirements2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSparseImageMemoryRequirements2(e, s, raw); +} + +void vkb_decfix_VkSparseImageMemoryRequirements2(vkb_dec *d, VkSparseImageMemoryRequirements2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSparseImageMemoryRequirements2(vkb_dec *d, VkSparseImageMemoryRequirements2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSparseImageMemoryRequirements2(d, s); +} + +void vkb_encfix_VkSparseImageOpaqueMemoryBindInfo(vkb_enc *e, const VkSparseImageOpaqueMemoryBindInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + if (s->pBinds) { + uint32_t n_ = (uint32_t)(s->bindCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pBinds, (size_t)n_ * sizeof(*s->pBinds)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkSparseImageOpaqueMemoryBindInfo(vkb_enc *e, const VkSparseImageOpaqueMemoryBindInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSparseImageOpaqueMemoryBindInfo(e, s, raw); +} + +void vkb_decfix_VkSparseImageOpaqueMemoryBindInfo(vkb_dec *d, VkSparseImageOpaqueMemoryBindInfo *s) +{ + (void)d; (void)s; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pBinds = (const VkSparseMemoryBind *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSparseMemoryBind)); + } else { + s->pBinds = NULL; + } +} + +void vkb_dec_VkSparseImageOpaqueMemoryBindInfo(vkb_dec *d, VkSparseImageOpaqueMemoryBindInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSparseImageOpaqueMemoryBindInfo(d, s); +} + +void vkb_encfix_VkSpecializationInfo(vkb_enc *e, const VkSpecializationInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + if (s->pMapEntries) { + uint32_t n_ = (uint32_t)(s->mapEntryCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pMapEntries, (size_t)n_ * sizeof(*s->pMapEntries)); + } else { + vkb_enc_u8(e, 0); + } + vkb_enc_blob(e, s->pData ? (const void *)s->pData : NULL, s->pData ? (size_t)(s->dataSize) : 0); +} + +void vkb_enc_VkSpecializationInfo(vkb_enc *e, const VkSpecializationInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSpecializationInfo(e, s, raw); +} + +void vkb_decfix_VkSpecializationInfo(vkb_dec *d, VkSpecializationInfo *s) +{ + (void)d; (void)s; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pMapEntries = (const VkSpecializationMapEntry *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSpecializationMapEntry)); + } else { + s->pMapEntries = NULL; + } + s->pData = (const void *)vkb_dec_blob(d, NULL); +} + +void vkb_dec_VkSpecializationInfo(vkb_dec *d, VkSpecializationInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSpecializationInfo(d, s); +} + +void vkb_encfix_VkSubmitInfo(vkb_enc *e, const VkSubmitInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pWaitSemaphores) { + uint32_t n_ = (uint32_t)(s->waitSemaphoreCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pWaitSemaphores, (size_t)n_ * sizeof(*s->pWaitSemaphores)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pWaitDstStageMask) { + uint32_t n_ = (uint32_t)(s->waitSemaphoreCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pWaitDstStageMask, (size_t)n_ * sizeof(*s->pWaitDstStageMask)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pCommandBuffers) { + uint32_t n_ = (uint32_t)(s->commandBufferCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_u64(e, vkb_remote((const void *)s->pCommandBuffers[i_])); + } else { + vkb_enc_u8(e, 0); + } + if (s->pSignalSemaphores) { + uint32_t n_ = (uint32_t)(s->signalSemaphoreCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pSignalSemaphores, (size_t)n_ * sizeof(*s->pSignalSemaphores)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkSubmitInfo(vkb_enc *e, const VkSubmitInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSubmitInfo(e, s, raw); +} + +void vkb_decfix_VkSubmitInfo(vkb_dec *d, VkSubmitInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pWaitSemaphores = (const VkSemaphore *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSemaphore)); + } else { + s->pWaitSemaphores = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pWaitDstStageMask = (const VkPipelineStageFlags *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkPipelineStageFlags)); + } else { + s->pWaitDstStageMask = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCommandBuffer *a_ = (VkCommandBuffer *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCommandBuffer)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) a_[i_] = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(d); + s->pCommandBuffers = a_; + } else { + s->pCommandBuffers = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pSignalSemaphores = (const VkSemaphore *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkSemaphore)); + } else { + s->pSignalSemaphores = NULL; + } +} + +void vkb_dec_VkSubmitInfo(vkb_dec *d, VkSubmitInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSubmitInfo(d, s); +} + +void vkb_encfix_VkSubmitInfo2(vkb_enc *e, const VkSubmitInfo2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pWaitSemaphoreInfos) { + uint32_t n_ = (uint32_t)(s->waitSemaphoreInfoCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSemaphoreSubmitInfo(e, &s->pWaitSemaphoreInfos[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pCommandBufferInfos) { + uint32_t n_ = (uint32_t)(s->commandBufferInfoCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkCommandBufferSubmitInfo(e, &s->pCommandBufferInfos[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pSignalSemaphoreInfos) { + uint32_t n_ = (uint32_t)(s->signalSemaphoreInfoCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkSemaphoreSubmitInfo(e, &s->pSignalSemaphoreInfos[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkSubmitInfo2(vkb_enc *e, const VkSubmitInfo2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSubmitInfo2(e, s, raw); +} + +void vkb_decfix_VkSubmitInfo2(vkb_dec *d, VkSubmitInfo2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSemaphoreSubmitInfo *a_ = (VkSemaphoreSubmitInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSemaphoreSubmitInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSemaphoreSubmitInfo(d, &a_[i_]); + s->pWaitSemaphoreInfos = a_; + } else { + s->pWaitSemaphoreInfos = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkCommandBufferSubmitInfo *a_ = (VkCommandBufferSubmitInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkCommandBufferSubmitInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkCommandBufferSubmitInfo(d, &a_[i_]); + s->pCommandBufferInfos = a_; + } else { + s->pCommandBufferInfos = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkSemaphoreSubmitInfo *a_ = (VkSemaphoreSubmitInfo *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkSemaphoreSubmitInfo)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkSemaphoreSubmitInfo(d, &a_[i_]); + s->pSignalSemaphoreInfos = a_; + } else { + s->pSignalSemaphoreInfos = NULL; + } +} + +void vkb_dec_VkSubmitInfo2(vkb_dec *d, VkSubmitInfo2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSubmitInfo2(d, s); +} + +void vkb_encfix_VkSubpassBeginInfo(vkb_enc *e, const VkSubpassBeginInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSubpassBeginInfo(vkb_enc *e, const VkSubpassBeginInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSubpassBeginInfo(e, s, raw); +} + +void vkb_decfix_VkSubpassBeginInfo(vkb_dec *d, VkSubpassBeginInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSubpassBeginInfo(vkb_dec *d, VkSubpassBeginInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSubpassBeginInfo(d, s); +} + +void vkb_encfix_VkSubpassDependency2(vkb_enc *e, const VkSubpassDependency2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSubpassDependency2(vkb_enc *e, const VkSubpassDependency2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSubpassDependency2(e, s, raw); +} + +void vkb_decfix_VkSubpassDependency2(vkb_dec *d, VkSubpassDependency2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSubpassDependency2(vkb_dec *d, VkSubpassDependency2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSubpassDependency2(d, s); +} + +void vkb_encfix_VkSubpassDescription(vkb_enc *e, const VkSubpassDescription *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + if (s->pInputAttachments) { + uint32_t n_ = (uint32_t)(s->inputAttachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pInputAttachments, (size_t)n_ * sizeof(*s->pInputAttachments)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pColorAttachments) { + uint32_t n_ = (uint32_t)(s->colorAttachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pColorAttachments, (size_t)n_ * sizeof(*s->pColorAttachments)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pResolveAttachments) { + uint32_t n_ = (uint32_t)(s->colorAttachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pResolveAttachments, (size_t)n_ * sizeof(*s->pResolveAttachments)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pDepthStencilAttachment) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pDepthStencilAttachment, (size_t)n_ * sizeof(*s->pDepthStencilAttachment)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pPreserveAttachments) { + uint32_t n_ = (uint32_t)(s->preserveAttachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pPreserveAttachments, (size_t)n_ * sizeof(*s->pPreserveAttachments)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkSubpassDescription(vkb_enc *e, const VkSubpassDescription *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSubpassDescription(e, s, raw); +} + +void vkb_decfix_VkSubpassDescription(vkb_dec *d, VkSubpassDescription *s) +{ + (void)d; (void)s; + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pInputAttachments = (const VkAttachmentReference *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkAttachmentReference)); + } else { + s->pInputAttachments = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pColorAttachments = (const VkAttachmentReference *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkAttachmentReference)); + } else { + s->pColorAttachments = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pResolveAttachments = (const VkAttachmentReference *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkAttachmentReference)); + } else { + s->pResolveAttachments = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pDepthStencilAttachment = (const VkAttachmentReference *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkAttachmentReference)); + } else { + s->pDepthStencilAttachment = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pPreserveAttachments = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pPreserveAttachments = NULL; + } +} + +void vkb_dec_VkSubpassDescription(vkb_dec *d, VkSubpassDescription *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSubpassDescription(d, s); +} + +void vkb_encfix_VkSubpassDescription2(vkb_enc *e, const VkSubpassDescription2 *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pInputAttachments) { + uint32_t n_ = (uint32_t)(s->inputAttachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkAttachmentReference2(e, &s->pInputAttachments[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pColorAttachments) { + uint32_t n_ = (uint32_t)(s->colorAttachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkAttachmentReference2(e, &s->pColorAttachments[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pResolveAttachments) { + uint32_t n_ = (uint32_t)(s->colorAttachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkAttachmentReference2(e, &s->pResolveAttachments[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pDepthStencilAttachment) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkAttachmentReference2(e, &s->pDepthStencilAttachment[i_]); + } else { + vkb_enc_u8(e, 0); + } + if (s->pPreserveAttachments) { + uint32_t n_ = (uint32_t)(s->preserveAttachmentCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pPreserveAttachments, (size_t)n_ * sizeof(*s->pPreserveAttachments)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkSubpassDescription2(vkb_enc *e, const VkSubpassDescription2 *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSubpassDescription2(e, s, raw); +} + +void vkb_decfix_VkSubpassDescription2(vkb_dec *d, VkSubpassDescription2 *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkAttachmentReference2 *a_ = (VkAttachmentReference2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkAttachmentReference2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkAttachmentReference2(d, &a_[i_]); + s->pInputAttachments = a_; + } else { + s->pInputAttachments = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkAttachmentReference2 *a_ = (VkAttachmentReference2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkAttachmentReference2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkAttachmentReference2(d, &a_[i_]); + s->pColorAttachments = a_; + } else { + s->pColorAttachments = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkAttachmentReference2 *a_ = (VkAttachmentReference2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkAttachmentReference2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkAttachmentReference2(d, &a_[i_]); + s->pResolveAttachments = a_; + } else { + s->pResolveAttachments = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkAttachmentReference2 *a_ = (VkAttachmentReference2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkAttachmentReference2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkAttachmentReference2(d, &a_[i_]); + s->pDepthStencilAttachment = a_; + } else { + s->pDepthStencilAttachment = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pPreserveAttachments = (const uint32_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint32_t)); + } else { + s->pPreserveAttachments = NULL; + } +} + +void vkb_dec_VkSubpassDescription2(vkb_dec *d, VkSubpassDescription2 *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSubpassDescription2(d, s); +} + +void vkb_encfix_VkSubpassDescriptionDepthStencilResolve(vkb_enc *e, const VkSubpassDescriptionDepthStencilResolve *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pDepthStencilResolveAttachment) { + uint32_t n_ = (uint32_t)(1); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + for (uint32_t i_ = 0; i_ < n_; i_++) vkb_enc_VkAttachmentReference2(e, &s->pDepthStencilResolveAttachment[i_]); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkSubpassDescriptionDepthStencilResolve(vkb_enc *e, const VkSubpassDescriptionDepthStencilResolve *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSubpassDescriptionDepthStencilResolve(e, s, raw); +} + +void vkb_decfix_VkSubpassDescriptionDepthStencilResolve(vkb_dec *d, VkSubpassDescriptionDepthStencilResolve *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + VkAttachmentReference2 *a_ = (VkAttachmentReference2 *)vkb_dec_alloc(d, (size_t)n_ * sizeof(VkAttachmentReference2)); + for (uint32_t i_ = 0; a_ && i_ < n_; i_++) vkb_dec_VkAttachmentReference2(d, &a_[i_]); + s->pDepthStencilResolveAttachment = a_; + } else { + s->pDepthStencilResolveAttachment = NULL; + } +} + +void vkb_dec_VkSubpassDescriptionDepthStencilResolve(vkb_dec *d, VkSubpassDescriptionDepthStencilResolve *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSubpassDescriptionDepthStencilResolve(d, s); +} + +void vkb_encfix_VkSubpassEndInfo(vkb_enc *e, const VkSubpassEndInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSubpassEndInfo(vkb_enc *e, const VkSubpassEndInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSubpassEndInfo(e, s, raw); +} + +void vkb_decfix_VkSubpassEndInfo(vkb_dec *d, VkSubpassEndInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSubpassEndInfo(vkb_dec *d, VkSubpassEndInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSubpassEndInfo(d, s); +} + +void vkb_encfix_VkSubpassResolvePerformanceQueryEXT(vkb_enc *e, const VkSubpassResolvePerformanceQueryEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSubpassResolvePerformanceQueryEXT(vkb_enc *e, const VkSubpassResolvePerformanceQueryEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSubpassResolvePerformanceQueryEXT(e, s, raw); +} + +void vkb_decfix_VkSubpassResolvePerformanceQueryEXT(vkb_dec *d, VkSubpassResolvePerformanceQueryEXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSubpassResolvePerformanceQueryEXT(vkb_dec *d, VkSubpassResolvePerformanceQueryEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSubpassResolvePerformanceQueryEXT(d, s); +} + +void vkb_encfix_VkSubpassSampleLocationsEXT(vkb_enc *e, const VkSubpassSampleLocationsEXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_encfix_VkSampleLocationsInfoEXT(e, &s->sampleLocationsInfo, raw + offsetof(VkSubpassSampleLocationsEXT, sampleLocationsInfo)); +} + +void vkb_enc_VkSubpassSampleLocationsEXT(vkb_enc *e, const VkSubpassSampleLocationsEXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSubpassSampleLocationsEXT(e, s, raw); +} + +void vkb_decfix_VkSubpassSampleLocationsEXT(vkb_dec *d, VkSubpassSampleLocationsEXT *s) +{ + (void)d; (void)s; + vkb_decfix_VkSampleLocationsInfoEXT(d, &s->sampleLocationsInfo); +} + +void vkb_dec_VkSubpassSampleLocationsEXT(vkb_dec *d, VkSubpassSampleLocationsEXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSubpassSampleLocationsEXT(d, s); +} + +void vkb_encfix_VkSubresourceLayout2EXT(vkb_enc *e, const VkSubresourceLayout2EXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkSubresourceLayout2EXT(vkb_enc *e, const VkSubresourceLayout2EXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkSubresourceLayout2EXT(e, s, raw); +} + +void vkb_decfix_VkSubresourceLayout2EXT(vkb_dec *d, VkSubresourceLayout2EXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkSubresourceLayout2EXT(vkb_dec *d, VkSubresourceLayout2EXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkSubresourceLayout2EXT(d, s); +} + +void vkb_encfix_VkTimelineSemaphoreSubmitInfo(vkb_enc *e, const VkTimelineSemaphoreSubmitInfo *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pWaitSemaphoreValues) { + uint32_t n_ = (uint32_t)(s->waitSemaphoreValueCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pWaitSemaphoreValues, (size_t)n_ * sizeof(*s->pWaitSemaphoreValues)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pSignalSemaphoreValues) { + uint32_t n_ = (uint32_t)(s->signalSemaphoreValueCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pSignalSemaphoreValues, (size_t)n_ * sizeof(*s->pSignalSemaphoreValues)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkTimelineSemaphoreSubmitInfo(vkb_enc *e, const VkTimelineSemaphoreSubmitInfo *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkTimelineSemaphoreSubmitInfo(e, s, raw); +} + +void vkb_decfix_VkTimelineSemaphoreSubmitInfo(vkb_dec *d, VkTimelineSemaphoreSubmitInfo *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pWaitSemaphoreValues = (const uint64_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint64_t)); + } else { + s->pWaitSemaphoreValues = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pSignalSemaphoreValues = (const uint64_t *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(uint64_t)); + } else { + s->pSignalSemaphoreValues = NULL; + } +} + +void vkb_dec_VkTimelineSemaphoreSubmitInfo(vkb_dec *d, VkTimelineSemaphoreSubmitInfo *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkTimelineSemaphoreSubmitInfo(d, s); +} + +void vkb_encfix_VkVertexInputAttributeDescription2EXT(vkb_enc *e, const VkVertexInputAttributeDescription2EXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkVertexInputAttributeDescription2EXT(vkb_enc *e, const VkVertexInputAttributeDescription2EXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkVertexInputAttributeDescription2EXT(e, s, raw); +} + +void vkb_decfix_VkVertexInputAttributeDescription2EXT(vkb_dec *d, VkVertexInputAttributeDescription2EXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkVertexInputAttributeDescription2EXT(vkb_dec *d, VkVertexInputAttributeDescription2EXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkVertexInputAttributeDescription2EXT(d, s); +} + +void vkb_encfix_VkVertexInputBindingDescription2EXT(vkb_enc *e, const VkVertexInputBindingDescription2EXT *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); +} + +void vkb_enc_VkVertexInputBindingDescription2EXT(vkb_enc *e, const VkVertexInputBindingDescription2EXT *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkVertexInputBindingDescription2EXT(e, s, raw); +} + +void vkb_decfix_VkVertexInputBindingDescription2EXT(vkb_dec *d, VkVertexInputBindingDescription2EXT *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); +} + +void vkb_dec_VkVertexInputBindingDescription2EXT(vkb_dec *d, VkVertexInputBindingDescription2EXT *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkVertexInputBindingDescription2EXT(d, s); +} + +void vkb_encfix_VkWriteDescriptorSet(vkb_enc *e, const VkWriteDescriptorSet *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + if (s->pImageInfo && (vkb_desc_has_image(s->descriptorType))) { + uint32_t n_ = (uint32_t)(s->descriptorCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pImageInfo, (size_t)n_ * sizeof(*s->pImageInfo)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pBufferInfo && (vkb_desc_has_buffer(s->descriptorType))) { + uint32_t n_ = (uint32_t)(s->descriptorCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pBufferInfo, (size_t)n_ * sizeof(*s->pBufferInfo)); + } else { + vkb_enc_u8(e, 0); + } + if (s->pTexelBufferView && (vkb_desc_has_texel(s->descriptorType))) { + uint32_t n_ = (uint32_t)(s->descriptorCount); + vkb_enc_u8(e, 1); vkb_enc_u32(e, n_); + vkb_enc_raw(e, s->pTexelBufferView, (size_t)n_ * sizeof(*s->pTexelBufferView)); + } else { + vkb_enc_u8(e, 0); + } +} + +void vkb_enc_VkWriteDescriptorSet(vkb_enc *e, const VkWriteDescriptorSet *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkWriteDescriptorSet(e, s, raw); +} + +void vkb_decfix_VkWriteDescriptorSet(vkb_dec *d, VkWriteDescriptorSet *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pImageInfo = (const VkDescriptorImageInfo *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDescriptorImageInfo)); + } else { + s->pImageInfo = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pBufferInfo = (const VkDescriptorBufferInfo *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkDescriptorBufferInfo)); + } else { + s->pBufferInfo = NULL; + } + if (vkb_dec_u8(d)) { + uint32_t n_ = vkb_dec_u32(d); + s->pTexelBufferView = (const VkBufferView *)vkb_dec_raw_view(d, (size_t)n_ * sizeof(VkBufferView)); + } else { + s->pTexelBufferView = NULL; + } +} + +void vkb_dec_VkWriteDescriptorSet(vkb_dec *d, VkWriteDescriptorSet *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkWriteDescriptorSet(d, s); +} + +void vkb_encfix_VkWriteDescriptorSetInlineUniformBlock(vkb_enc *e, const VkWriteDescriptorSetInlineUniformBlock *s, size_t raw) +{ + (void)e; (void)s; (void)raw; + vkb_enc_chain(e, s->pNext); + vkb_enc_blob(e, s->pData ? (const void *)s->pData : NULL, s->pData ? (size_t)(s->dataSize) : 0); +} + +void vkb_enc_VkWriteDescriptorSetInlineUniformBlock(vkb_enc *e, const VkWriteDescriptorSetInlineUniformBlock *s) +{ + size_t raw = vkb_enc_raw(e, s, sizeof(*s)); + vkb_encfix_VkWriteDescriptorSetInlineUniformBlock(e, s, raw); +} + +void vkb_decfix_VkWriteDescriptorSetInlineUniformBlock(vkb_dec *d, VkWriteDescriptorSetInlineUniformBlock *s) +{ + (void)d; (void)s; + s->pNext = (void *)vkb_dec_chain(d); + s->pData = (const void *)vkb_dec_blob(d, NULL); +} + +void vkb_dec_VkWriteDescriptorSetInlineUniformBlock(vkb_dec *d, VkWriteDescriptorSetInlineUniformBlock *s) +{ + vkb_dec_raw_into(d, s, sizeof(*s)); + vkb_decfix_VkWriteDescriptorSetInlineUniformBlock(d, s); +} + +size_t vkb_struct_size(VkStructureType t) +{ + switch ((int)t) { + case VK_STRUCTURE_TYPE_APPLICATION_INFO: return sizeof(VkApplicationInfo); + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: return sizeof(VkAttachmentDescription2); + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: return sizeof(VkAttachmentDescriptionStencilLayout); + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: return sizeof(VkAttachmentReference2); + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: return sizeof(VkAttachmentReferenceStencilLayout); + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: return sizeof(VkBindBufferMemoryDeviceGroupInfo); + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: return sizeof(VkBindBufferMemoryInfo); + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: return sizeof(VkBindImageMemoryDeviceGroupInfo); + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: return sizeof(VkBindImageMemoryInfo); + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: return sizeof(VkBindImageMemorySwapchainInfoKHR); + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: return sizeof(VkBindImagePlaneMemoryInfo); + case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: return sizeof(VkBindSparseInfo); + case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: return sizeof(VkBlitImageInfo2); + case VK_STRUCTURE_TYPE_BUFFER_COPY_2: return sizeof(VkBufferCopy2); + case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: return sizeof(VkBufferCreateInfo); + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: return sizeof(VkBufferDeviceAddressCreateInfoEXT); + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: return sizeof(VkBufferDeviceAddressInfo); + case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: return sizeof(VkBufferImageCopy2); + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: return sizeof(VkBufferMemoryBarrier); + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: return sizeof(VkBufferMemoryBarrier2); + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: return sizeof(VkBufferMemoryRequirementsInfo2); + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: return sizeof(VkBufferOpaqueCaptureAddressCreateInfo); + case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: return sizeof(VkBufferViewCreateInfo); + case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: return sizeof(VkCalibratedTimestampInfoEXT); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: return sizeof(VkCommandBufferAllocateInfo); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: return sizeof(VkCommandBufferBeginInfo); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: return sizeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: return sizeof(VkCommandBufferInheritanceInfo); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: return sizeof(VkCommandBufferInheritanceRenderingInfo); + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: return sizeof(VkCommandBufferSubmitInfo); + case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: return sizeof(VkCommandPoolCreateInfo); + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: return sizeof(VkComputePipelineCreateInfo); + case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: return sizeof(VkConditionalRenderingBeginInfoEXT); + case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: return sizeof(VkCopyBufferInfo2); + case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: return sizeof(VkCopyBufferToImageInfo2); + case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: return sizeof(VkCopyDescriptorSet); + case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: return sizeof(VkCopyImageInfo2); + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: return sizeof(VkCopyImageToBufferInfo2); + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: return sizeof(VkDebugUtilsObjectNameInfoEXT); + case VK_STRUCTURE_TYPE_DEPENDENCY_INFO: return sizeof(VkDependencyInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: return sizeof(VkDescriptorPoolCreateInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: return sizeof(VkDescriptorPoolInlineUniformBlockCreateInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: return sizeof(VkDescriptorSetAllocateInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: return sizeof(VkDescriptorSetLayoutBindingFlagsCreateInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: return sizeof(VkDescriptorSetLayoutCreateInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: return sizeof(VkDescriptorSetLayoutSupport); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: return sizeof(VkDescriptorSetVariableDescriptorCountAllocateInfo); + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: return sizeof(VkDescriptorSetVariableDescriptorCountLayoutSupport); + case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: return sizeof(VkDescriptorUpdateTemplateCreateInfo); + case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: return sizeof(VkDeviceBufferMemoryRequirements); + case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: return sizeof(VkDeviceCreateInfo); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: return sizeof(VkDeviceGroupBindSparseInfo); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: return sizeof(VkDeviceGroupCommandBufferBeginInfo); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: return sizeof(VkDeviceGroupDeviceCreateInfo); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: return sizeof(VkDeviceGroupRenderPassBeginInfo); + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: return sizeof(VkDeviceGroupSubmitInfo); + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: return sizeof(VkDeviceImageMemoryRequirements); + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: return sizeof(VkDeviceMemoryOpaqueCaptureAddressInfo); + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: return sizeof(VkDevicePrivateDataCreateInfo); + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: return sizeof(VkDeviceQueueCreateInfo); + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: return sizeof(VkDeviceQueueGlobalPriorityCreateInfoKHR); + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: return sizeof(VkDeviceQueueInfo2); + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: return sizeof(VkDrmFormatModifierPropertiesList2EXT); + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: return sizeof(VkDrmFormatModifierPropertiesListEXT); + case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: return sizeof(VkEventCreateInfo); + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: return sizeof(VkExportFenceCreateInfo); + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: return sizeof(VkExportMemoryAllocateInfo); + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: return sizeof(VkExportSemaphoreCreateInfo); + case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: return sizeof(VkExternalBufferProperties); + case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: return sizeof(VkExternalFenceProperties); + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: return sizeof(VkExternalImageFormatProperties); + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: return sizeof(VkExternalMemoryBufferCreateInfo); + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: return sizeof(VkExternalMemoryImageCreateInfo); + case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: return sizeof(VkExternalSemaphoreProperties); + case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: return sizeof(VkFenceCreateInfo); + case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: return sizeof(VkFenceGetFdInfoKHR); + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: return sizeof(VkFilterCubicImageViewImageFormatPropertiesEXT); + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: return sizeof(VkFormatProperties2); + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: return sizeof(VkFormatProperties3); + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: return sizeof(VkFragmentShadingRateAttachmentInfoKHR); + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: return sizeof(VkFramebufferAttachmentImageInfo); + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: return sizeof(VkFramebufferAttachmentsCreateInfo); + case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: return sizeof(VkFramebufferCreateInfo); + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: return sizeof(VkGraphicsPipelineCreateInfo); + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: return sizeof(VkGraphicsPipelineLibraryCreateInfoEXT); + case VK_STRUCTURE_TYPE_IMAGE_BLIT_2: return sizeof(VkImageBlit2); + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: return sizeof(VkImageCompressionControlEXT); + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: return sizeof(VkImageCompressionPropertiesEXT); + case VK_STRUCTURE_TYPE_IMAGE_COPY_2: return sizeof(VkImageCopy2); + case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: return sizeof(VkImageCreateInfo); + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: return sizeof(VkImageDrmFormatModifierExplicitCreateInfoEXT); + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: return sizeof(VkImageDrmFormatModifierListCreateInfoEXT); + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: return sizeof(VkImageDrmFormatModifierPropertiesEXT); + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: return sizeof(VkImageFormatListCreateInfo); + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: return sizeof(VkImageFormatProperties2); + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: return sizeof(VkImageMemoryBarrier); + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: return sizeof(VkImageMemoryBarrier2); + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: return sizeof(VkImageMemoryRequirementsInfo2); + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: return sizeof(VkImagePlaneMemoryRequirementsInfo); + case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: return sizeof(VkImageResolve2); + case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: return sizeof(VkImageSparseMemoryRequirementsInfo2); + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: return sizeof(VkImageStencilUsageCreateInfo); + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT: return sizeof(VkImageSubresource2EXT); + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: return sizeof(VkImageSwapchainCreateInfoKHR); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: return sizeof(VkImageViewASTCDecodeModeEXT); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: return sizeof(VkImageViewCreateInfo); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: return sizeof(VkImageViewMinLodCreateInfoEXT); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: return sizeof(VkImageViewSlicedCreateInfoEXT); + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: return sizeof(VkImageViewUsageCreateInfo); + case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: return sizeof(VkImportFenceFdInfoKHR); + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: return sizeof(VkImportMemoryFdInfoKHR); + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: return sizeof(VkImportSemaphoreFdInfoKHR); + case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: return sizeof(VkInstanceCreateInfo); + case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: return sizeof(VkMappedMemoryRange); + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: return sizeof(VkMemoryAllocateFlagsInfo); + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: return sizeof(VkMemoryAllocateInfo); + case VK_STRUCTURE_TYPE_MEMORY_BARRIER: return sizeof(VkMemoryBarrier); + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: return sizeof(VkMemoryBarrier2); + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: return sizeof(VkMemoryDedicatedAllocateInfo); + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: return sizeof(VkMemoryDedicatedRequirements); + case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: return sizeof(VkMemoryFdPropertiesKHR); + case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: return sizeof(VkMemoryGetFdInfoKHR); + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: return sizeof(VkMemoryOpaqueCaptureAddressAllocateInfo); + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: return sizeof(VkMemoryPriorityAllocateInfoEXT); + case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: return sizeof(VkMemoryRequirements2); + case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: return sizeof(VkMultisamplePropertiesEXT); + case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: return sizeof(VkMultisampledRenderToSingleSampledInfoEXT); + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: return sizeof(VkMutableDescriptorTypeCreateInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: return sizeof(VkPhysicalDevice16BitStorageFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: return sizeof(VkPhysicalDevice4444FormatsFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: return sizeof(VkPhysicalDevice8BitStorageFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: return sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: return sizeof(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: return sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: return sizeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: return sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: return sizeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: return sizeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: return sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: return sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceCustomBorderColorPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: return sizeof(VkPhysicalDeviceDepthClampZeroOneFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: return sizeof(VkPhysicalDeviceDepthClipControlFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: return sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: return sizeof(VkPhysicalDeviceDepthStencilResolveProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: return sizeof(VkPhysicalDeviceDescriptorIndexingFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: return sizeof(VkPhysicalDeviceDescriptorIndexingProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: return sizeof(VkPhysicalDeviceDriverProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceDrmPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: return sizeof(VkPhysicalDeviceDynamicRenderingFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: return sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: return sizeof(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: return sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: return sizeof(VkPhysicalDeviceExternalBufferInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: return sizeof(VkPhysicalDeviceExternalFenceInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: return sizeof(VkPhysicalDeviceExternalImageFormatInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: return sizeof(VkPhysicalDeviceExternalSemaphoreInfo); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: return sizeof(VkPhysicalDeviceFeatures2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: return sizeof(VkPhysicalDeviceFloatControlsProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: return sizeof(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: return sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: return sizeof(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: return sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: return sizeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: return sizeof(VkPhysicalDeviceFragmentShadingRateKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: return sizeof(VkPhysicalDeviceFragmentShadingRatePropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: return sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: return sizeof(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: return sizeof(VkPhysicalDeviceGroupProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: return sizeof(VkPhysicalDeviceHostQueryResetFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: return sizeof(VkPhysicalDeviceIDProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: return sizeof(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: return sizeof(VkPhysicalDeviceImageCompressionControlFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: return sizeof(VkPhysicalDeviceImageDrmFormatModifierInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: return sizeof(VkPhysicalDeviceImageFormatInfo2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: return sizeof(VkPhysicalDeviceImageRobustnessFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: return sizeof(VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: return sizeof(VkPhysicalDeviceImageViewImageFormatInfoEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: return sizeof(VkPhysicalDeviceImageViewMinLodFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: return sizeof(VkPhysicalDeviceImagelessFramebufferFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: return sizeof(VkPhysicalDeviceIndexTypeUint8FeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: return sizeof(VkPhysicalDeviceInlineUniformBlockFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: return sizeof(VkPhysicalDeviceInlineUniformBlockProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: return sizeof(VkPhysicalDeviceLegacyDitheringFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: return sizeof(VkPhysicalDeviceLineRasterizationFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceLineRasterizationPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: return sizeof(VkPhysicalDeviceMaintenance3Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: return sizeof(VkPhysicalDeviceMaintenance4Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: return sizeof(VkPhysicalDeviceMaintenance4Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: return sizeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: return sizeof(VkPhysicalDeviceMemoryProperties2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: return sizeof(VkPhysicalDeviceMultiDrawFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceMultiDrawPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: return sizeof(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: return sizeof(VkPhysicalDeviceMultiviewFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: return sizeof(VkPhysicalDeviceMultiviewProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: return sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: return sizeof(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: return sizeof(VkPhysicalDevicePCIBusInfoPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: return sizeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: return sizeof(VkPhysicalDevicePipelineCreationCacheControlFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: return sizeof(VkPhysicalDevicePipelineProtectedAccessFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: return sizeof(VkPhysicalDevicePipelineRobustnessFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: return sizeof(VkPhysicalDevicePipelineRobustnessPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: return sizeof(VkPhysicalDevicePointClippingProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: return sizeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: return sizeof(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: return sizeof(VkPhysicalDevicePrivateDataFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: return sizeof(VkPhysicalDeviceProperties2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: return sizeof(VkPhysicalDeviceProtectedMemoryFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: return sizeof(VkPhysicalDeviceProtectedMemoryProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: return sizeof(VkPhysicalDeviceProvokingVertexFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceProvokingVertexPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: return sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: return sizeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: return sizeof(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: return sizeof(VkPhysicalDeviceRobustness2FeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceRobustness2PropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceSampleLocationsPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: return sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: return sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: return sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: return sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: return sizeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: return sizeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: return sizeof(VkPhysicalDeviceShaderAtomicInt64Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: return sizeof(VkPhysicalDeviceShaderClockFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: return sizeof(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: return sizeof(VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: return sizeof(VkPhysicalDeviceShaderCorePropertiesARM); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: return sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: return sizeof(VkPhysicalDeviceShaderDrawParametersFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: return sizeof(VkPhysicalDeviceShaderFloat16Int8Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: return sizeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: return sizeof(VkPhysicalDeviceShaderIntegerDotProductFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: return sizeof(VkPhysicalDeviceShaderIntegerDotProductProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: return sizeof(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: return sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: return sizeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: return sizeof(VkPhysicalDeviceShaderTerminateInvocationFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: return sizeof(VkPhysicalDeviceShaderTileImageFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceShaderTileImagePropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: return sizeof(VkPhysicalDeviceSparseImageFormatInfo2); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: return sizeof(VkPhysicalDeviceSubgroupProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: return sizeof(VkPhysicalDeviceSubgroupSizeControlFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: return sizeof(VkPhysicalDeviceSubgroupSizeControlProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: return sizeof(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: return sizeof(VkPhysicalDeviceSynchronization2Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: return sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: return sizeof(VkPhysicalDeviceTexelBufferAlignmentProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: return sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: return sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: return sizeof(VkPhysicalDeviceTimelineSemaphoreProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: return sizeof(VkPhysicalDeviceToolProperties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: return sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: return sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: return sizeof(VkPhysicalDeviceVariablePointersFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: return sizeof(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: return sizeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: return sizeof(VkPhysicalDeviceVulkan11Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: return sizeof(VkPhysicalDeviceVulkan11Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: return sizeof(VkPhysicalDeviceVulkan12Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: return sizeof(VkPhysicalDeviceVulkan12Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: return sizeof(VkPhysicalDeviceVulkan13Features); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: return sizeof(VkPhysicalDeviceVulkan13Properties); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: return sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: return sizeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: return sizeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: return sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT); + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: return sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures); + case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: return sizeof(VkPipelineCacheCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: return sizeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: return sizeof(VkPipelineColorBlendStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: return sizeof(VkPipelineColorWriteCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: return sizeof(VkPipelineCreationFeedbackCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: return sizeof(VkPipelineDepthStencilStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: return sizeof(VkPipelineDiscardRectangleStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: return sizeof(VkPipelineDynamicStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: return sizeof(VkPipelineFragmentShadingRateStateCreateInfoKHR); + case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: return sizeof(VkPipelineInputAssemblyStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: return sizeof(VkPipelineLayoutCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: return sizeof(VkPipelineLibraryCreateInfoKHR); + case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: return sizeof(VkPipelineMultisampleStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: return sizeof(VkPipelineRasterizationConservativeStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: return sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: return sizeof(VkPipelineRasterizationLineStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: return sizeof(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: return sizeof(VkPipelineRasterizationStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: return sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: return sizeof(VkPipelineRenderingCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: return sizeof(VkPipelineRobustnessCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: return sizeof(VkPipelineSampleLocationsStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: return sizeof(VkPipelineShaderStageCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: return sizeof(VkPipelineShaderStageModuleIdentifierCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: return sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: return sizeof(VkPipelineTessellationDomainOriginStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: return sizeof(VkPipelineTessellationStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: return sizeof(VkPipelineVertexInputDivisorStateCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: return sizeof(VkPipelineVertexInputStateCreateInfo); + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: return sizeof(VkPipelineViewportDepthClipControlCreateInfoEXT); + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: return sizeof(VkPipelineViewportStateCreateInfo); + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: return sizeof(VkProtectedSubmitInfo); + case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: return sizeof(VkQueryPoolCreateInfo); + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: return sizeof(VkQueueFamilyGlobalPriorityPropertiesKHR); + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: return sizeof(VkQueueFamilyProperties2); + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: return sizeof(VkRenderPassAttachmentBeginInfo); + case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: return sizeof(VkRenderPassBeginInfo); + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: return sizeof(VkRenderPassCreateInfo); + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: return sizeof(VkRenderPassCreateInfo2); + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: return sizeof(VkRenderPassCreationControlEXT); + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: return sizeof(VkRenderPassCreationFeedbackCreateInfoEXT); + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT); + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: return sizeof(VkRenderPassInputAttachmentAspectCreateInfo); + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: return sizeof(VkRenderPassMultiviewCreateInfo); + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: return sizeof(VkRenderPassSampleLocationsBeginInfoEXT); + case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: return sizeof(VkRenderPassSubpassFeedbackCreateInfoEXT); + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: return sizeof(VkRenderingAttachmentInfo); + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: return sizeof(VkRenderingFragmentDensityMapAttachmentInfoEXT); + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: return sizeof(VkRenderingFragmentShadingRateAttachmentInfoKHR); + case VK_STRUCTURE_TYPE_RENDERING_INFO: return sizeof(VkRenderingInfo); + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: return sizeof(VkResolveImageInfo2); + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: return sizeof(VkSampleLocationsInfoEXT); + case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: return sizeof(VkSamplerBorderColorComponentMappingCreateInfoEXT); + case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: return sizeof(VkSamplerCreateInfo); + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: return sizeof(VkSamplerCustomBorderColorCreateInfoEXT); + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: return sizeof(VkSamplerReductionModeCreateInfo); + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: return sizeof(VkSamplerYcbcrConversionCreateInfo); + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: return sizeof(VkSamplerYcbcrConversionImageFormatProperties); + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: return sizeof(VkSamplerYcbcrConversionInfo); + case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: return sizeof(VkSemaphoreCreateInfo); + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: return sizeof(VkSemaphoreGetFdInfoKHR); + case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: return sizeof(VkSemaphoreSignalInfo); + case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: return sizeof(VkSemaphoreSubmitInfo); + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: return sizeof(VkSemaphoreTypeCreateInfo); + case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: return sizeof(VkSemaphoreWaitInfo); + case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: return sizeof(VkShaderModuleCreateInfo); + case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: return sizeof(VkShaderModuleIdentifierEXT); + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: return sizeof(VkSparseImageFormatProperties2); + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: return sizeof(VkSparseImageMemoryRequirements2); + case VK_STRUCTURE_TYPE_SUBMIT_INFO: return sizeof(VkSubmitInfo); + case VK_STRUCTURE_TYPE_SUBMIT_INFO_2: return sizeof(VkSubmitInfo2); + case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: return sizeof(VkSubpassBeginInfo); + case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: return sizeof(VkSubpassDependency2); + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: return sizeof(VkSubpassDescription2); + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: return sizeof(VkSubpassDescriptionDepthStencilResolve); + case VK_STRUCTURE_TYPE_SUBPASS_END_INFO: return sizeof(VkSubpassEndInfo); + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: return sizeof(VkSubpassResolvePerformanceQueryEXT); + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT: return sizeof(VkSubresourceLayout2EXT); + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: return sizeof(VkTimelineSemaphoreSubmitInfo); + case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: return sizeof(VkVertexInputAttributeDescription2EXT); + case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: return sizeof(VkVertexInputBindingDescription2EXT); + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: return sizeof(VkWriteDescriptorSet); + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: return sizeof(VkWriteDescriptorSetInlineUniformBlock); + default: return 0; + } +} + +void vkb_enc_chain_elem(vkb_enc *e, const VkBaseInStructure *b) +{ + switch ((int)b->sType) { + case VK_STRUCTURE_TYPE_APPLICATION_INFO: vkb_enc_VkApplicationInfo(e, (const VkApplicationInfo *)b); return; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: vkb_enc_VkAttachmentDescription2(e, (const VkAttachmentDescription2 *)b); return; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: vkb_enc_VkAttachmentDescriptionStencilLayout(e, (const VkAttachmentDescriptionStencilLayout *)b); return; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: vkb_enc_VkAttachmentReference2(e, (const VkAttachmentReference2 *)b); return; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: vkb_enc_VkAttachmentReferenceStencilLayout(e, (const VkAttachmentReferenceStencilLayout *)b); return; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: vkb_enc_VkBindBufferMemoryDeviceGroupInfo(e, (const VkBindBufferMemoryDeviceGroupInfo *)b); return; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: vkb_enc_VkBindBufferMemoryInfo(e, (const VkBindBufferMemoryInfo *)b); return; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: vkb_enc_VkBindImageMemoryDeviceGroupInfo(e, (const VkBindImageMemoryDeviceGroupInfo *)b); return; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: vkb_enc_VkBindImageMemoryInfo(e, (const VkBindImageMemoryInfo *)b); return; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: vkb_enc_VkBindImageMemorySwapchainInfoKHR(e, (const VkBindImageMemorySwapchainInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: vkb_enc_VkBindImagePlaneMemoryInfo(e, (const VkBindImagePlaneMemoryInfo *)b); return; + case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: vkb_enc_VkBindSparseInfo(e, (const VkBindSparseInfo *)b); return; + case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: vkb_enc_VkBlitImageInfo2(e, (const VkBlitImageInfo2 *)b); return; + case VK_STRUCTURE_TYPE_BUFFER_COPY_2: vkb_enc_VkBufferCopy2(e, (const VkBufferCopy2 *)b); return; + case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: vkb_enc_VkBufferCreateInfo(e, (const VkBufferCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: vkb_enc_VkBufferDeviceAddressCreateInfoEXT(e, (const VkBufferDeviceAddressCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: vkb_enc_VkBufferDeviceAddressInfo(e, (const VkBufferDeviceAddressInfo *)b); return; + case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: vkb_enc_VkBufferImageCopy2(e, (const VkBufferImageCopy2 *)b); return; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: vkb_enc_VkBufferMemoryBarrier(e, (const VkBufferMemoryBarrier *)b); return; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: vkb_enc_VkBufferMemoryBarrier2(e, (const VkBufferMemoryBarrier2 *)b); return; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: vkb_enc_VkBufferMemoryRequirementsInfo2(e, (const VkBufferMemoryRequirementsInfo2 *)b); return; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: vkb_enc_VkBufferOpaqueCaptureAddressCreateInfo(e, (const VkBufferOpaqueCaptureAddressCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: vkb_enc_VkBufferViewCreateInfo(e, (const VkBufferViewCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: vkb_enc_VkCalibratedTimestampInfoEXT(e, (const VkCalibratedTimestampInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: vkb_enc_VkCommandBufferAllocateInfo(e, (const VkCommandBufferAllocateInfo *)b); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: vkb_enc_VkCommandBufferBeginInfo(e, (const VkCommandBufferBeginInfo *)b); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: vkb_enc_VkCommandBufferInheritanceConditionalRenderingInfoEXT(e, (const VkCommandBufferInheritanceConditionalRenderingInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: vkb_enc_VkCommandBufferInheritanceInfo(e, (const VkCommandBufferInheritanceInfo *)b); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: vkb_enc_VkCommandBufferInheritanceRenderingInfo(e, (const VkCommandBufferInheritanceRenderingInfo *)b); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: vkb_enc_VkCommandBufferSubmitInfo(e, (const VkCommandBufferSubmitInfo *)b); return; + case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: vkb_enc_VkCommandPoolCreateInfo(e, (const VkCommandPoolCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: vkb_enc_VkComputePipelineCreateInfo(e, (const VkComputePipelineCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: vkb_enc_VkConditionalRenderingBeginInfoEXT(e, (const VkConditionalRenderingBeginInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: vkb_enc_VkCopyBufferInfo2(e, (const VkCopyBufferInfo2 *)b); return; + case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: vkb_enc_VkCopyBufferToImageInfo2(e, (const VkCopyBufferToImageInfo2 *)b); return; + case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: vkb_enc_VkCopyDescriptorSet(e, (const VkCopyDescriptorSet *)b); return; + case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: vkb_enc_VkCopyImageInfo2(e, (const VkCopyImageInfo2 *)b); return; + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: vkb_enc_VkCopyImageToBufferInfo2(e, (const VkCopyImageToBufferInfo2 *)b); return; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: vkb_enc_VkDebugUtilsObjectNameInfoEXT(e, (const VkDebugUtilsObjectNameInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_DEPENDENCY_INFO: vkb_enc_VkDependencyInfo(e, (const VkDependencyInfo *)b); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: vkb_enc_VkDescriptorPoolCreateInfo(e, (const VkDescriptorPoolCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: vkb_enc_VkDescriptorPoolInlineUniformBlockCreateInfo(e, (const VkDescriptorPoolInlineUniformBlockCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: vkb_enc_VkDescriptorSetAllocateInfo(e, (const VkDescriptorSetAllocateInfo *)b); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: vkb_enc_VkDescriptorSetLayoutBindingFlagsCreateInfo(e, (const VkDescriptorSetLayoutBindingFlagsCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: vkb_enc_VkDescriptorSetLayoutCreateInfo(e, (const VkDescriptorSetLayoutCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: vkb_enc_VkDescriptorSetLayoutSupport(e, (const VkDescriptorSetLayoutSupport *)b); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: vkb_enc_VkDescriptorSetVariableDescriptorCountAllocateInfo(e, (const VkDescriptorSetVariableDescriptorCountAllocateInfo *)b); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: vkb_enc_VkDescriptorSetVariableDescriptorCountLayoutSupport(e, (const VkDescriptorSetVariableDescriptorCountLayoutSupport *)b); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: vkb_enc_VkDescriptorUpdateTemplateCreateInfo(e, (const VkDescriptorUpdateTemplateCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: vkb_enc_VkDeviceBufferMemoryRequirements(e, (const VkDeviceBufferMemoryRequirements *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: vkb_enc_VkDeviceCreateInfo(e, (const VkDeviceCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: vkb_enc_VkDeviceGroupBindSparseInfo(e, (const VkDeviceGroupBindSparseInfo *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: vkb_enc_VkDeviceGroupCommandBufferBeginInfo(e, (const VkDeviceGroupCommandBufferBeginInfo *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: vkb_enc_VkDeviceGroupDeviceCreateInfo(e, (const VkDeviceGroupDeviceCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: vkb_enc_VkDeviceGroupRenderPassBeginInfo(e, (const VkDeviceGroupRenderPassBeginInfo *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: vkb_enc_VkDeviceGroupSubmitInfo(e, (const VkDeviceGroupSubmitInfo *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: vkb_enc_VkDeviceImageMemoryRequirements(e, (const VkDeviceImageMemoryRequirements *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: vkb_enc_VkDeviceMemoryOpaqueCaptureAddressInfo(e, (const VkDeviceMemoryOpaqueCaptureAddressInfo *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: vkb_enc_VkDevicePrivateDataCreateInfo(e, (const VkDevicePrivateDataCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: vkb_enc_VkDeviceQueueCreateInfo(e, (const VkDeviceQueueCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: vkb_enc_VkDeviceQueueGlobalPriorityCreateInfoKHR(e, (const VkDeviceQueueGlobalPriorityCreateInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: vkb_enc_VkDeviceQueueInfo2(e, (const VkDeviceQueueInfo2 *)b); return; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: vkb_enc_VkDrmFormatModifierPropertiesList2EXT(e, (const VkDrmFormatModifierPropertiesList2EXT *)b); return; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: vkb_enc_VkDrmFormatModifierPropertiesListEXT(e, (const VkDrmFormatModifierPropertiesListEXT *)b); return; + case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: vkb_enc_VkEventCreateInfo(e, (const VkEventCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: vkb_enc_VkExportFenceCreateInfo(e, (const VkExportFenceCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: vkb_enc_VkExportMemoryAllocateInfo(e, (const VkExportMemoryAllocateInfo *)b); return; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: vkb_enc_VkExportSemaphoreCreateInfo(e, (const VkExportSemaphoreCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: vkb_enc_VkExternalBufferProperties(e, (const VkExternalBufferProperties *)b); return; + case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: vkb_enc_VkExternalFenceProperties(e, (const VkExternalFenceProperties *)b); return; + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: vkb_enc_VkExternalImageFormatProperties(e, (const VkExternalImageFormatProperties *)b); return; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: vkb_enc_VkExternalMemoryBufferCreateInfo(e, (const VkExternalMemoryBufferCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: vkb_enc_VkExternalMemoryImageCreateInfo(e, (const VkExternalMemoryImageCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: vkb_enc_VkExternalSemaphoreProperties(e, (const VkExternalSemaphoreProperties *)b); return; + case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: vkb_enc_VkFenceCreateInfo(e, (const VkFenceCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: vkb_enc_VkFenceGetFdInfoKHR(e, (const VkFenceGetFdInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: vkb_enc_VkFilterCubicImageViewImageFormatPropertiesEXT(e, (const VkFilterCubicImageViewImageFormatPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: vkb_enc_VkFormatProperties2(e, (const VkFormatProperties2 *)b); return; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: vkb_enc_VkFormatProperties3(e, (const VkFormatProperties3 *)b); return; + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: vkb_enc_VkFragmentShadingRateAttachmentInfoKHR(e, (const VkFragmentShadingRateAttachmentInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: vkb_enc_VkFramebufferAttachmentImageInfo(e, (const VkFramebufferAttachmentImageInfo *)b); return; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: vkb_enc_VkFramebufferAttachmentsCreateInfo(e, (const VkFramebufferAttachmentsCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: vkb_enc_VkFramebufferCreateInfo(e, (const VkFramebufferCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: vkb_enc_VkGraphicsPipelineCreateInfo(e, (const VkGraphicsPipelineCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: vkb_enc_VkGraphicsPipelineLibraryCreateInfoEXT(e, (const VkGraphicsPipelineLibraryCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_BLIT_2: vkb_enc_VkImageBlit2(e, (const VkImageBlit2 *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: vkb_enc_VkImageCompressionControlEXT(e, (const VkImageCompressionControlEXT *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: vkb_enc_VkImageCompressionPropertiesEXT(e, (const VkImageCompressionPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_COPY_2: vkb_enc_VkImageCopy2(e, (const VkImageCopy2 *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: vkb_enc_VkImageCreateInfo(e, (const VkImageCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: vkb_enc_VkImageDrmFormatModifierExplicitCreateInfoEXT(e, (const VkImageDrmFormatModifierExplicitCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: vkb_enc_VkImageDrmFormatModifierListCreateInfoEXT(e, (const VkImageDrmFormatModifierListCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: vkb_enc_VkImageDrmFormatModifierPropertiesEXT(e, (const VkImageDrmFormatModifierPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: vkb_enc_VkImageFormatListCreateInfo(e, (const VkImageFormatListCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: vkb_enc_VkImageFormatProperties2(e, (const VkImageFormatProperties2 *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: vkb_enc_VkImageMemoryBarrier(e, (const VkImageMemoryBarrier *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: vkb_enc_VkImageMemoryBarrier2(e, (const VkImageMemoryBarrier2 *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: vkb_enc_VkImageMemoryRequirementsInfo2(e, (const VkImageMemoryRequirementsInfo2 *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: vkb_enc_VkImagePlaneMemoryRequirementsInfo(e, (const VkImagePlaneMemoryRequirementsInfo *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: vkb_enc_VkImageResolve2(e, (const VkImageResolve2 *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: vkb_enc_VkImageSparseMemoryRequirementsInfo2(e, (const VkImageSparseMemoryRequirementsInfo2 *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: vkb_enc_VkImageStencilUsageCreateInfo(e, (const VkImageStencilUsageCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT: vkb_enc_VkImageSubresource2EXT(e, (const VkImageSubresource2EXT *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: vkb_enc_VkImageSwapchainCreateInfoKHR(e, (const VkImageSwapchainCreateInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: vkb_enc_VkImageViewASTCDecodeModeEXT(e, (const VkImageViewASTCDecodeModeEXT *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: vkb_enc_VkImageViewCreateInfo(e, (const VkImageViewCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: vkb_enc_VkImageViewMinLodCreateInfoEXT(e, (const VkImageViewMinLodCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: vkb_enc_VkImageViewSlicedCreateInfoEXT(e, (const VkImageViewSlicedCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: vkb_enc_VkImageViewUsageCreateInfo(e, (const VkImageViewUsageCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: vkb_enc_VkImportFenceFdInfoKHR(e, (const VkImportFenceFdInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: vkb_enc_VkImportMemoryFdInfoKHR(e, (const VkImportMemoryFdInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: vkb_enc_VkImportSemaphoreFdInfoKHR(e, (const VkImportSemaphoreFdInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: vkb_enc_VkInstanceCreateInfo(e, (const VkInstanceCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: vkb_enc_VkMappedMemoryRange(e, (const VkMappedMemoryRange *)b); return; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: vkb_enc_VkMemoryAllocateFlagsInfo(e, (const VkMemoryAllocateFlagsInfo *)b); return; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: vkb_enc_VkMemoryAllocateInfo(e, (const VkMemoryAllocateInfo *)b); return; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER: vkb_enc_VkMemoryBarrier(e, (const VkMemoryBarrier *)b); return; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: vkb_enc_VkMemoryBarrier2(e, (const VkMemoryBarrier2 *)b); return; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: vkb_enc_VkMemoryDedicatedAllocateInfo(e, (const VkMemoryDedicatedAllocateInfo *)b); return; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: vkb_enc_VkMemoryDedicatedRequirements(e, (const VkMemoryDedicatedRequirements *)b); return; + case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: vkb_enc_VkMemoryFdPropertiesKHR(e, (const VkMemoryFdPropertiesKHR *)b); return; + case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: vkb_enc_VkMemoryGetFdInfoKHR(e, (const VkMemoryGetFdInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: vkb_enc_VkMemoryOpaqueCaptureAddressAllocateInfo(e, (const VkMemoryOpaqueCaptureAddressAllocateInfo *)b); return; + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: vkb_enc_VkMemoryPriorityAllocateInfoEXT(e, (const VkMemoryPriorityAllocateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: vkb_enc_VkMemoryRequirements2(e, (const VkMemoryRequirements2 *)b); return; + case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: vkb_enc_VkMultisamplePropertiesEXT(e, (const VkMultisamplePropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: vkb_enc_VkMultisampledRenderToSingleSampledInfoEXT(e, (const VkMultisampledRenderToSingleSampledInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: vkb_enc_VkMutableDescriptorTypeCreateInfoEXT(e, (const VkMutableDescriptorTypeCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: vkb_enc_VkPhysicalDevice16BitStorageFeatures(e, (const VkPhysicalDevice16BitStorageFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: vkb_enc_VkPhysicalDevice4444FormatsFeaturesEXT(e, (const VkPhysicalDevice4444FormatsFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: vkb_enc_VkPhysicalDevice8BitStorageFeatures(e, (const VkPhysicalDevice8BitStorageFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: vkb_enc_VkPhysicalDeviceASTCDecodeFeaturesEXT(e, (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: vkb_enc_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(e, (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: vkb_enc_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(e, (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(e, (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: vkb_enc_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(e, (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: vkb_enc_VkPhysicalDeviceBufferDeviceAddressFeatures(e, (const VkPhysicalDeviceBufferDeviceAddressFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: vkb_enc_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(e, (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: vkb_enc_VkPhysicalDeviceColorWriteEnableFeaturesEXT(e, (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: vkb_enc_VkPhysicalDeviceConditionalRenderingFeaturesEXT(e, (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(e, (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: vkb_enc_VkPhysicalDeviceCustomBorderColorFeaturesEXT(e, (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceCustomBorderColorPropertiesEXT(e, (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: vkb_enc_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(e, (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: vkb_enc_VkPhysicalDeviceDepthClipControlFeaturesEXT(e, (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: vkb_enc_VkPhysicalDeviceDepthClipEnableFeaturesEXT(e, (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: vkb_enc_VkPhysicalDeviceDepthStencilResolveProperties(e, (const VkPhysicalDeviceDepthStencilResolveProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: vkb_enc_VkPhysicalDeviceDescriptorIndexingFeatures(e, (const VkPhysicalDeviceDescriptorIndexingFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: vkb_enc_VkPhysicalDeviceDescriptorIndexingProperties(e, (const VkPhysicalDeviceDescriptorIndexingProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceDiscardRectanglePropertiesEXT(e, (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: vkb_enc_VkPhysicalDeviceDriverProperties(e, (const VkPhysicalDeviceDriverProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceDrmPropertiesEXT(e, (const VkPhysicalDeviceDrmPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: vkb_enc_VkPhysicalDeviceDynamicRenderingFeatures(e, (const VkPhysicalDeviceDynamicRenderingFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: vkb_enc_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(e, (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: vkb_enc_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(e, (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(e, (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: vkb_enc_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(e, (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: vkb_enc_VkPhysicalDeviceExternalBufferInfo(e, (const VkPhysicalDeviceExternalBufferInfo *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: vkb_enc_VkPhysicalDeviceExternalFenceInfo(e, (const VkPhysicalDeviceExternalFenceInfo *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: vkb_enc_VkPhysicalDeviceExternalImageFormatInfo(e, (const VkPhysicalDeviceExternalImageFormatInfo *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: vkb_enc_VkPhysicalDeviceExternalSemaphoreInfo(e, (const VkPhysicalDeviceExternalSemaphoreInfo *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: vkb_enc_VkPhysicalDeviceFeatures2(e, (const VkPhysicalDeviceFeatures2 *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: vkb_enc_VkPhysicalDeviceFloatControlsProperties(e, (const VkPhysicalDeviceFloatControlsProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: vkb_enc_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(e, (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(e, (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: vkb_enc_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(e, (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(e, (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: vkb_enc_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(e, (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: vkb_enc_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(e, (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: vkb_enc_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(e, (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: vkb_enc_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(e, (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: vkb_enc_VkPhysicalDeviceFragmentShadingRateKHR(e, (const VkPhysicalDeviceFragmentShadingRateKHR *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: vkb_enc_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(e, (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: vkb_enc_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(e, (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: vkb_enc_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(e, (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(e, (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: vkb_enc_VkPhysicalDeviceGroupProperties(e, (const VkPhysicalDeviceGroupProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: vkb_enc_VkPhysicalDeviceHostQueryResetFeatures(e, (const VkPhysicalDeviceHostQueryResetFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: vkb_enc_VkPhysicalDeviceIDProperties(e, (const VkPhysicalDeviceIDProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: vkb_enc_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(e, (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: vkb_enc_VkPhysicalDeviceImageCompressionControlFeaturesEXT(e, (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: vkb_enc_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(e, (const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: vkb_enc_VkPhysicalDeviceImageFormatInfo2(e, (const VkPhysicalDeviceImageFormatInfo2 *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: vkb_enc_VkPhysicalDeviceImageRobustnessFeatures(e, (const VkPhysicalDeviceImageRobustnessFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: vkb_enc_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(e, (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: vkb_enc_VkPhysicalDeviceImageViewImageFormatInfoEXT(e, (const VkPhysicalDeviceImageViewImageFormatInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: vkb_enc_VkPhysicalDeviceImageViewMinLodFeaturesEXT(e, (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: vkb_enc_VkPhysicalDeviceImagelessFramebufferFeatures(e, (const VkPhysicalDeviceImagelessFramebufferFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: vkb_enc_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(e, (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: vkb_enc_VkPhysicalDeviceInlineUniformBlockFeatures(e, (const VkPhysicalDeviceInlineUniformBlockFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: vkb_enc_VkPhysicalDeviceInlineUniformBlockProperties(e, (const VkPhysicalDeviceInlineUniformBlockProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: vkb_enc_VkPhysicalDeviceLegacyDitheringFeaturesEXT(e, (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: vkb_enc_VkPhysicalDeviceLineRasterizationFeaturesEXT(e, (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceLineRasterizationPropertiesEXT(e, (const VkPhysicalDeviceLineRasterizationPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: vkb_enc_VkPhysicalDeviceMaintenance3Properties(e, (const VkPhysicalDeviceMaintenance3Properties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: vkb_enc_VkPhysicalDeviceMaintenance4Features(e, (const VkPhysicalDeviceMaintenance4Features *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: vkb_enc_VkPhysicalDeviceMaintenance4Properties(e, (const VkPhysicalDeviceMaintenance4Properties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceMemoryBudgetPropertiesEXT(e, (const VkPhysicalDeviceMemoryBudgetPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: vkb_enc_VkPhysicalDeviceMemoryPriorityFeaturesEXT(e, (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: vkb_enc_VkPhysicalDeviceMemoryProperties2(e, (const VkPhysicalDeviceMemoryProperties2 *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: vkb_enc_VkPhysicalDeviceMultiDrawFeaturesEXT(e, (const VkPhysicalDeviceMultiDrawFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceMultiDrawPropertiesEXT(e, (const VkPhysicalDeviceMultiDrawPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: vkb_enc_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(e, (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: vkb_enc_VkPhysicalDeviceMultiviewFeatures(e, (const VkPhysicalDeviceMultiviewFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: vkb_enc_VkPhysicalDeviceMultiviewProperties(e, (const VkPhysicalDeviceMultiviewProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: vkb_enc_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(e, (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: vkb_enc_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(e, (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: vkb_enc_VkPhysicalDevicePCIBusInfoPropertiesEXT(e, (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: vkb_enc_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(e, (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: vkb_enc_VkPhysicalDevicePipelineCreationCacheControlFeatures(e, (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: vkb_enc_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(e, (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: vkb_enc_VkPhysicalDevicePipelineRobustnessFeaturesEXT(e, (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: vkb_enc_VkPhysicalDevicePipelineRobustnessPropertiesEXT(e, (const VkPhysicalDevicePipelineRobustnessPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: vkb_enc_VkPhysicalDevicePointClippingProperties(e, (const VkPhysicalDevicePointClippingProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: vkb_enc_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(e, (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: vkb_enc_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(e, (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: vkb_enc_VkPhysicalDevicePrivateDataFeatures(e, (const VkPhysicalDevicePrivateDataFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: vkb_enc_VkPhysicalDeviceProperties2(e, (const VkPhysicalDeviceProperties2 *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: vkb_enc_VkPhysicalDeviceProtectedMemoryFeatures(e, (const VkPhysicalDeviceProtectedMemoryFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: vkb_enc_VkPhysicalDeviceProtectedMemoryProperties(e, (const VkPhysicalDeviceProtectedMemoryProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: vkb_enc_VkPhysicalDeviceProvokingVertexFeaturesEXT(e, (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceProvokingVertexPropertiesEXT(e, (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: vkb_enc_VkPhysicalDevicePushDescriptorPropertiesKHR(e, (const VkPhysicalDevicePushDescriptorPropertiesKHR *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: vkb_enc_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(e, (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: vkb_enc_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(e, (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: vkb_enc_VkPhysicalDeviceRobustness2FeaturesEXT(e, (const VkPhysicalDeviceRobustness2FeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceRobustness2PropertiesEXT(e, (const VkPhysicalDeviceRobustness2PropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceSampleLocationsPropertiesEXT(e, (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: vkb_enc_VkPhysicalDeviceSamplerFilterMinmaxProperties(e, (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: vkb_enc_VkPhysicalDeviceSamplerYcbcrConversionFeatures(e, (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: vkb_enc_VkPhysicalDeviceScalarBlockLayoutFeatures(e, (const VkPhysicalDeviceScalarBlockLayoutFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: vkb_enc_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(e, (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: vkb_enc_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(e, (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: vkb_enc_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(e, (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: vkb_enc_VkPhysicalDeviceShaderAtomicInt64Features(e, (const VkPhysicalDeviceShaderAtomicInt64Features *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: vkb_enc_VkPhysicalDeviceShaderClockFeaturesKHR(e, (const VkPhysicalDeviceShaderClockFeaturesKHR *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: vkb_enc_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(e, (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: vkb_enc_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(e, (const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: vkb_enc_VkPhysicalDeviceShaderCorePropertiesARM(e, (const VkPhysicalDeviceShaderCorePropertiesARM *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: vkb_enc_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(e, (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: vkb_enc_VkPhysicalDeviceShaderDrawParametersFeatures(e, (const VkPhysicalDeviceShaderDrawParametersFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: vkb_enc_VkPhysicalDeviceShaderFloat16Int8Features(e, (const VkPhysicalDeviceShaderFloat16Int8Features *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: vkb_enc_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(e, (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: vkb_enc_VkPhysicalDeviceShaderIntegerDotProductFeatures(e, (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: vkb_enc_VkPhysicalDeviceShaderIntegerDotProductProperties(e, (const VkPhysicalDeviceShaderIntegerDotProductProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: vkb_enc_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(e, (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(e, (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: vkb_enc_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(e, (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: vkb_enc_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(e, (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: vkb_enc_VkPhysicalDeviceShaderTerminateInvocationFeatures(e, (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: vkb_enc_VkPhysicalDeviceShaderTileImageFeaturesEXT(e, (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceShaderTileImagePropertiesEXT(e, (const VkPhysicalDeviceShaderTileImagePropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: vkb_enc_VkPhysicalDeviceSparseImageFormatInfo2(e, (const VkPhysicalDeviceSparseImageFormatInfo2 *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: vkb_enc_VkPhysicalDeviceSubgroupProperties(e, (const VkPhysicalDeviceSubgroupProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: vkb_enc_VkPhysicalDeviceSubgroupSizeControlFeatures(e, (const VkPhysicalDeviceSubgroupSizeControlFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: vkb_enc_VkPhysicalDeviceSubgroupSizeControlProperties(e, (const VkPhysicalDeviceSubgroupSizeControlProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: vkb_enc_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(e, (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: vkb_enc_VkPhysicalDeviceSynchronization2Features(e, (const VkPhysicalDeviceSynchronization2Features *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: vkb_enc_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(e, (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: vkb_enc_VkPhysicalDeviceTexelBufferAlignmentProperties(e, (const VkPhysicalDeviceTexelBufferAlignmentProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: vkb_enc_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(e, (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: vkb_enc_VkPhysicalDeviceTimelineSemaphoreFeatures(e, (const VkPhysicalDeviceTimelineSemaphoreFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: vkb_enc_VkPhysicalDeviceTimelineSemaphoreProperties(e, (const VkPhysicalDeviceTimelineSemaphoreProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: vkb_enc_VkPhysicalDeviceToolProperties(e, (const VkPhysicalDeviceToolProperties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: vkb_enc_VkPhysicalDeviceTransformFeedbackFeaturesEXT(e, (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceTransformFeedbackPropertiesEXT(e, (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: vkb_enc_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(e, (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: vkb_enc_VkPhysicalDeviceVariablePointersFeatures(e, (const VkPhysicalDeviceVariablePointersFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: vkb_enc_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(e, (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: vkb_enc_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(e, (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: vkb_enc_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(e, (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: vkb_enc_VkPhysicalDeviceVulkan11Features(e, (const VkPhysicalDeviceVulkan11Features *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: vkb_enc_VkPhysicalDeviceVulkan11Properties(e, (const VkPhysicalDeviceVulkan11Properties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: vkb_enc_VkPhysicalDeviceVulkan12Features(e, (const VkPhysicalDeviceVulkan12Features *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: vkb_enc_VkPhysicalDeviceVulkan12Properties(e, (const VkPhysicalDeviceVulkan12Properties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: vkb_enc_VkPhysicalDeviceVulkan13Features(e, (const VkPhysicalDeviceVulkan13Features *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: vkb_enc_VkPhysicalDeviceVulkan13Properties(e, (const VkPhysicalDeviceVulkan13Properties *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: vkb_enc_VkPhysicalDeviceVulkanMemoryModelFeatures(e, (const VkPhysicalDeviceVulkanMemoryModelFeatures *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: vkb_enc_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(e, (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: vkb_enc_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(e, (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: vkb_enc_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(e, (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)b); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: vkb_enc_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(e, (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: vkb_enc_VkPipelineCacheCreateInfo(e, (const VkPipelineCacheCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: vkb_enc_VkPipelineColorBlendAdvancedStateCreateInfoEXT(e, (const VkPipelineColorBlendAdvancedStateCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: vkb_enc_VkPipelineColorBlendStateCreateInfo(e, (const VkPipelineColorBlendStateCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: vkb_enc_VkPipelineColorWriteCreateInfoEXT(e, (const VkPipelineColorWriteCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: vkb_enc_VkPipelineCreationFeedbackCreateInfo(e, (const VkPipelineCreationFeedbackCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: vkb_enc_VkPipelineDepthStencilStateCreateInfo(e, (const VkPipelineDepthStencilStateCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: vkb_enc_VkPipelineDiscardRectangleStateCreateInfoEXT(e, (const VkPipelineDiscardRectangleStateCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: vkb_enc_VkPipelineDynamicStateCreateInfo(e, (const VkPipelineDynamicStateCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: vkb_enc_VkPipelineFragmentShadingRateStateCreateInfoKHR(e, (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: vkb_enc_VkPipelineInputAssemblyStateCreateInfo(e, (const VkPipelineInputAssemblyStateCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: vkb_enc_VkPipelineLayoutCreateInfo(e, (const VkPipelineLayoutCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: vkb_enc_VkPipelineLibraryCreateInfoKHR(e, (const VkPipelineLibraryCreateInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: vkb_enc_VkPipelineMultisampleStateCreateInfo(e, (const VkPipelineMultisampleStateCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: vkb_enc_VkPipelineRasterizationConservativeStateCreateInfoEXT(e, (const VkPipelineRasterizationConservativeStateCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: vkb_enc_VkPipelineRasterizationDepthClipStateCreateInfoEXT(e, (const VkPipelineRasterizationDepthClipStateCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: vkb_enc_VkPipelineRasterizationLineStateCreateInfoEXT(e, (const VkPipelineRasterizationLineStateCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: vkb_enc_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(e, (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: vkb_enc_VkPipelineRasterizationStateCreateInfo(e, (const VkPipelineRasterizationStateCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: vkb_enc_VkPipelineRasterizationStateStreamCreateInfoEXT(e, (const VkPipelineRasterizationStateStreamCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: vkb_enc_VkPipelineRenderingCreateInfo(e, (const VkPipelineRenderingCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: vkb_enc_VkPipelineRobustnessCreateInfoEXT(e, (const VkPipelineRobustnessCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: vkb_enc_VkPipelineSampleLocationsStateCreateInfoEXT(e, (const VkPipelineSampleLocationsStateCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: vkb_enc_VkPipelineShaderStageCreateInfo(e, (const VkPipelineShaderStageCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: vkb_enc_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(e, (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: vkb_enc_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(e, (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: vkb_enc_VkPipelineTessellationDomainOriginStateCreateInfo(e, (const VkPipelineTessellationDomainOriginStateCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: vkb_enc_VkPipelineTessellationStateCreateInfo(e, (const VkPipelineTessellationStateCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: vkb_enc_VkPipelineVertexInputDivisorStateCreateInfoEXT(e, (const VkPipelineVertexInputDivisorStateCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: vkb_enc_VkPipelineVertexInputStateCreateInfo(e, (const VkPipelineVertexInputStateCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: vkb_enc_VkPipelineViewportDepthClipControlCreateInfoEXT(e, (const VkPipelineViewportDepthClipControlCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: vkb_enc_VkPipelineViewportStateCreateInfo(e, (const VkPipelineViewportStateCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: vkb_enc_VkProtectedSubmitInfo(e, (const VkProtectedSubmitInfo *)b); return; + case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: vkb_enc_VkQueryPoolCreateInfo(e, (const VkQueryPoolCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: vkb_enc_VkQueueFamilyGlobalPriorityPropertiesKHR(e, (const VkQueueFamilyGlobalPriorityPropertiesKHR *)b); return; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: vkb_enc_VkQueueFamilyProperties2(e, (const VkQueueFamilyProperties2 *)b); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: vkb_enc_VkRenderPassAttachmentBeginInfo(e, (const VkRenderPassAttachmentBeginInfo *)b); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: vkb_enc_VkRenderPassBeginInfo(e, (const VkRenderPassBeginInfo *)b); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: vkb_enc_VkRenderPassCreateInfo(e, (const VkRenderPassCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: vkb_enc_VkRenderPassCreateInfo2(e, (const VkRenderPassCreateInfo2 *)b); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: vkb_enc_VkRenderPassCreationControlEXT(e, (const VkRenderPassCreationControlEXT *)b); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: vkb_enc_VkRenderPassCreationFeedbackCreateInfoEXT(e, (const VkRenderPassCreationFeedbackCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: vkb_enc_VkRenderPassFragmentDensityMapCreateInfoEXT(e, (const VkRenderPassFragmentDensityMapCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: vkb_enc_VkRenderPassInputAttachmentAspectCreateInfo(e, (const VkRenderPassInputAttachmentAspectCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: vkb_enc_VkRenderPassMultiviewCreateInfo(e, (const VkRenderPassMultiviewCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: vkb_enc_VkRenderPassSampleLocationsBeginInfoEXT(e, (const VkRenderPassSampleLocationsBeginInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: vkb_enc_VkRenderPassSubpassFeedbackCreateInfoEXT(e, (const VkRenderPassSubpassFeedbackCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: vkb_enc_VkRenderingAttachmentInfo(e, (const VkRenderingAttachmentInfo *)b); return; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: vkb_enc_VkRenderingFragmentDensityMapAttachmentInfoEXT(e, (const VkRenderingFragmentDensityMapAttachmentInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: vkb_enc_VkRenderingFragmentShadingRateAttachmentInfoKHR(e, (const VkRenderingFragmentShadingRateAttachmentInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_RENDERING_INFO: vkb_enc_VkRenderingInfo(e, (const VkRenderingInfo *)b); return; + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: vkb_enc_VkResolveImageInfo2(e, (const VkResolveImageInfo2 *)b); return; + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: vkb_enc_VkSampleLocationsInfoEXT(e, (const VkSampleLocationsInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: vkb_enc_VkSamplerBorderColorComponentMappingCreateInfoEXT(e, (const VkSamplerBorderColorComponentMappingCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: vkb_enc_VkSamplerCreateInfo(e, (const VkSamplerCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: vkb_enc_VkSamplerCustomBorderColorCreateInfoEXT(e, (const VkSamplerCustomBorderColorCreateInfoEXT *)b); return; + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: vkb_enc_VkSamplerReductionModeCreateInfo(e, (const VkSamplerReductionModeCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: vkb_enc_VkSamplerYcbcrConversionCreateInfo(e, (const VkSamplerYcbcrConversionCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: vkb_enc_VkSamplerYcbcrConversionImageFormatProperties(e, (const VkSamplerYcbcrConversionImageFormatProperties *)b); return; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: vkb_enc_VkSamplerYcbcrConversionInfo(e, (const VkSamplerYcbcrConversionInfo *)b); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: vkb_enc_VkSemaphoreCreateInfo(e, (const VkSemaphoreCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: vkb_enc_VkSemaphoreGetFdInfoKHR(e, (const VkSemaphoreGetFdInfoKHR *)b); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: vkb_enc_VkSemaphoreSignalInfo(e, (const VkSemaphoreSignalInfo *)b); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: vkb_enc_VkSemaphoreSubmitInfo(e, (const VkSemaphoreSubmitInfo *)b); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: vkb_enc_VkSemaphoreTypeCreateInfo(e, (const VkSemaphoreTypeCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: vkb_enc_VkSemaphoreWaitInfo(e, (const VkSemaphoreWaitInfo *)b); return; + case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: vkb_enc_VkShaderModuleCreateInfo(e, (const VkShaderModuleCreateInfo *)b); return; + case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: vkb_enc_VkShaderModuleIdentifierEXT(e, (const VkShaderModuleIdentifierEXT *)b); return; + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: vkb_enc_VkSparseImageFormatProperties2(e, (const VkSparseImageFormatProperties2 *)b); return; + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: vkb_enc_VkSparseImageMemoryRequirements2(e, (const VkSparseImageMemoryRequirements2 *)b); return; + case VK_STRUCTURE_TYPE_SUBMIT_INFO: vkb_enc_VkSubmitInfo(e, (const VkSubmitInfo *)b); return; + case VK_STRUCTURE_TYPE_SUBMIT_INFO_2: vkb_enc_VkSubmitInfo2(e, (const VkSubmitInfo2 *)b); return; + case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: vkb_enc_VkSubpassBeginInfo(e, (const VkSubpassBeginInfo *)b); return; + case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: vkb_enc_VkSubpassDependency2(e, (const VkSubpassDependency2 *)b); return; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: vkb_enc_VkSubpassDescription2(e, (const VkSubpassDescription2 *)b); return; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: vkb_enc_VkSubpassDescriptionDepthStencilResolve(e, (const VkSubpassDescriptionDepthStencilResolve *)b); return; + case VK_STRUCTURE_TYPE_SUBPASS_END_INFO: vkb_enc_VkSubpassEndInfo(e, (const VkSubpassEndInfo *)b); return; + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: vkb_enc_VkSubpassResolvePerformanceQueryEXT(e, (const VkSubpassResolvePerformanceQueryEXT *)b); return; + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT: vkb_enc_VkSubresourceLayout2EXT(e, (const VkSubresourceLayout2EXT *)b); return; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: vkb_enc_VkTimelineSemaphoreSubmitInfo(e, (const VkTimelineSemaphoreSubmitInfo *)b); return; + case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: vkb_enc_VkVertexInputAttributeDescription2EXT(e, (const VkVertexInputAttributeDescription2EXT *)b); return; + case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: vkb_enc_VkVertexInputBindingDescription2EXT(e, (const VkVertexInputBindingDescription2EXT *)b); return; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: vkb_enc_VkWriteDescriptorSet(e, (const VkWriteDescriptorSet *)b); return; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: vkb_enc_VkWriteDescriptorSetInlineUniformBlock(e, (const VkWriteDescriptorSetInlineUniformBlock *)b); return; + default: vkb_enc_raw(e, b, vkb_struct_size(b->sType)); return; + } +} + +void vkb_dec_chain_elem(vkb_dec *d, VkStructureType t, void *dst) +{ + switch ((int)t) { + case VK_STRUCTURE_TYPE_APPLICATION_INFO: vkb_dec_VkApplicationInfo(d, (VkApplicationInfo *)dst); return; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: vkb_dec_VkAttachmentDescription2(d, (VkAttachmentDescription2 *)dst); return; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: vkb_dec_VkAttachmentDescriptionStencilLayout(d, (VkAttachmentDescriptionStencilLayout *)dst); return; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: vkb_dec_VkAttachmentReference2(d, (VkAttachmentReference2 *)dst); return; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: vkb_dec_VkAttachmentReferenceStencilLayout(d, (VkAttachmentReferenceStencilLayout *)dst); return; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: vkb_dec_VkBindBufferMemoryDeviceGroupInfo(d, (VkBindBufferMemoryDeviceGroupInfo *)dst); return; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: vkb_dec_VkBindBufferMemoryInfo(d, (VkBindBufferMemoryInfo *)dst); return; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: vkb_dec_VkBindImageMemoryDeviceGroupInfo(d, (VkBindImageMemoryDeviceGroupInfo *)dst); return; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: vkb_dec_VkBindImageMemoryInfo(d, (VkBindImageMemoryInfo *)dst); return; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: vkb_dec_VkBindImageMemorySwapchainInfoKHR(d, (VkBindImageMemorySwapchainInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: vkb_dec_VkBindImagePlaneMemoryInfo(d, (VkBindImagePlaneMemoryInfo *)dst); return; + case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: vkb_dec_VkBindSparseInfo(d, (VkBindSparseInfo *)dst); return; + case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: vkb_dec_VkBlitImageInfo2(d, (VkBlitImageInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_BUFFER_COPY_2: vkb_dec_VkBufferCopy2(d, (VkBufferCopy2 *)dst); return; + case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: vkb_dec_VkBufferCreateInfo(d, (VkBufferCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: vkb_dec_VkBufferDeviceAddressCreateInfoEXT(d, (VkBufferDeviceAddressCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: vkb_dec_VkBufferDeviceAddressInfo(d, (VkBufferDeviceAddressInfo *)dst); return; + case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: vkb_dec_VkBufferImageCopy2(d, (VkBufferImageCopy2 *)dst); return; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: vkb_dec_VkBufferMemoryBarrier(d, (VkBufferMemoryBarrier *)dst); return; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: vkb_dec_VkBufferMemoryBarrier2(d, (VkBufferMemoryBarrier2 *)dst); return; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: vkb_dec_VkBufferMemoryRequirementsInfo2(d, (VkBufferMemoryRequirementsInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: vkb_dec_VkBufferOpaqueCaptureAddressCreateInfo(d, (VkBufferOpaqueCaptureAddressCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: vkb_dec_VkBufferViewCreateInfo(d, (VkBufferViewCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: vkb_dec_VkCalibratedTimestampInfoEXT(d, (VkCalibratedTimestampInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: vkb_dec_VkCommandBufferAllocateInfo(d, (VkCommandBufferAllocateInfo *)dst); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: vkb_dec_VkCommandBufferBeginInfo(d, (VkCommandBufferBeginInfo *)dst); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: vkb_dec_VkCommandBufferInheritanceConditionalRenderingInfoEXT(d, (VkCommandBufferInheritanceConditionalRenderingInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: vkb_dec_VkCommandBufferInheritanceInfo(d, (VkCommandBufferInheritanceInfo *)dst); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: vkb_dec_VkCommandBufferInheritanceRenderingInfo(d, (VkCommandBufferInheritanceRenderingInfo *)dst); return; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: vkb_dec_VkCommandBufferSubmitInfo(d, (VkCommandBufferSubmitInfo *)dst); return; + case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: vkb_dec_VkCommandPoolCreateInfo(d, (VkCommandPoolCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: vkb_dec_VkComputePipelineCreateInfo(d, (VkComputePipelineCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: vkb_dec_VkConditionalRenderingBeginInfoEXT(d, (VkConditionalRenderingBeginInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: vkb_dec_VkCopyBufferInfo2(d, (VkCopyBufferInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: vkb_dec_VkCopyBufferToImageInfo2(d, (VkCopyBufferToImageInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: vkb_dec_VkCopyDescriptorSet(d, (VkCopyDescriptorSet *)dst); return; + case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: vkb_dec_VkCopyImageInfo2(d, (VkCopyImageInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: vkb_dec_VkCopyImageToBufferInfo2(d, (VkCopyImageToBufferInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: vkb_dec_VkDebugUtilsObjectNameInfoEXT(d, (VkDebugUtilsObjectNameInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_DEPENDENCY_INFO: vkb_dec_VkDependencyInfo(d, (VkDependencyInfo *)dst); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: vkb_dec_VkDescriptorPoolCreateInfo(d, (VkDescriptorPoolCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: vkb_dec_VkDescriptorPoolInlineUniformBlockCreateInfo(d, (VkDescriptorPoolInlineUniformBlockCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: vkb_dec_VkDescriptorSetAllocateInfo(d, (VkDescriptorSetAllocateInfo *)dst); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: vkb_dec_VkDescriptorSetLayoutBindingFlagsCreateInfo(d, (VkDescriptorSetLayoutBindingFlagsCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: vkb_dec_VkDescriptorSetLayoutCreateInfo(d, (VkDescriptorSetLayoutCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: vkb_dec_VkDescriptorSetLayoutSupport(d, (VkDescriptorSetLayoutSupport *)dst); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: vkb_dec_VkDescriptorSetVariableDescriptorCountAllocateInfo(d, (VkDescriptorSetVariableDescriptorCountAllocateInfo *)dst); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: vkb_dec_VkDescriptorSetVariableDescriptorCountLayoutSupport(d, (VkDescriptorSetVariableDescriptorCountLayoutSupport *)dst); return; + case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: vkb_dec_VkDescriptorUpdateTemplateCreateInfo(d, (VkDescriptorUpdateTemplateCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: vkb_dec_VkDeviceBufferMemoryRequirements(d, (VkDeviceBufferMemoryRequirements *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: vkb_dec_VkDeviceCreateInfo(d, (VkDeviceCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: vkb_dec_VkDeviceGroupBindSparseInfo(d, (VkDeviceGroupBindSparseInfo *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: vkb_dec_VkDeviceGroupCommandBufferBeginInfo(d, (VkDeviceGroupCommandBufferBeginInfo *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: vkb_dec_VkDeviceGroupDeviceCreateInfo(d, (VkDeviceGroupDeviceCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: vkb_dec_VkDeviceGroupRenderPassBeginInfo(d, (VkDeviceGroupRenderPassBeginInfo *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: vkb_dec_VkDeviceGroupSubmitInfo(d, (VkDeviceGroupSubmitInfo *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: vkb_dec_VkDeviceImageMemoryRequirements(d, (VkDeviceImageMemoryRequirements *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: vkb_dec_VkDeviceMemoryOpaqueCaptureAddressInfo(d, (VkDeviceMemoryOpaqueCaptureAddressInfo *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: vkb_dec_VkDevicePrivateDataCreateInfo(d, (VkDevicePrivateDataCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: vkb_dec_VkDeviceQueueCreateInfo(d, (VkDeviceQueueCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: vkb_dec_VkDeviceQueueGlobalPriorityCreateInfoKHR(d, (VkDeviceQueueGlobalPriorityCreateInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: vkb_dec_VkDeviceQueueInfo2(d, (VkDeviceQueueInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: vkb_dec_VkDrmFormatModifierPropertiesList2EXT(d, (VkDrmFormatModifierPropertiesList2EXT *)dst); return; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: vkb_dec_VkDrmFormatModifierPropertiesListEXT(d, (VkDrmFormatModifierPropertiesListEXT *)dst); return; + case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: vkb_dec_VkEventCreateInfo(d, (VkEventCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: vkb_dec_VkExportFenceCreateInfo(d, (VkExportFenceCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: vkb_dec_VkExportMemoryAllocateInfo(d, (VkExportMemoryAllocateInfo *)dst); return; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: vkb_dec_VkExportSemaphoreCreateInfo(d, (VkExportSemaphoreCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: vkb_dec_VkExternalBufferProperties(d, (VkExternalBufferProperties *)dst); return; + case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: vkb_dec_VkExternalFenceProperties(d, (VkExternalFenceProperties *)dst); return; + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: vkb_dec_VkExternalImageFormatProperties(d, (VkExternalImageFormatProperties *)dst); return; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: vkb_dec_VkExternalMemoryBufferCreateInfo(d, (VkExternalMemoryBufferCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: vkb_dec_VkExternalMemoryImageCreateInfo(d, (VkExternalMemoryImageCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: vkb_dec_VkExternalSemaphoreProperties(d, (VkExternalSemaphoreProperties *)dst); return; + case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: vkb_dec_VkFenceCreateInfo(d, (VkFenceCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: vkb_dec_VkFenceGetFdInfoKHR(d, (VkFenceGetFdInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: vkb_dec_VkFilterCubicImageViewImageFormatPropertiesEXT(d, (VkFilterCubicImageViewImageFormatPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: vkb_dec_VkFormatProperties2(d, (VkFormatProperties2 *)dst); return; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: vkb_dec_VkFormatProperties3(d, (VkFormatProperties3 *)dst); return; + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: vkb_dec_VkFragmentShadingRateAttachmentInfoKHR(d, (VkFragmentShadingRateAttachmentInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: vkb_dec_VkFramebufferAttachmentImageInfo(d, (VkFramebufferAttachmentImageInfo *)dst); return; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: vkb_dec_VkFramebufferAttachmentsCreateInfo(d, (VkFramebufferAttachmentsCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: vkb_dec_VkFramebufferCreateInfo(d, (VkFramebufferCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: vkb_dec_VkGraphicsPipelineCreateInfo(d, (VkGraphicsPipelineCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: vkb_dec_VkGraphicsPipelineLibraryCreateInfoEXT(d, (VkGraphicsPipelineLibraryCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_BLIT_2: vkb_dec_VkImageBlit2(d, (VkImageBlit2 *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: vkb_dec_VkImageCompressionControlEXT(d, (VkImageCompressionControlEXT *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: vkb_dec_VkImageCompressionPropertiesEXT(d, (VkImageCompressionPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_COPY_2: vkb_dec_VkImageCopy2(d, (VkImageCopy2 *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: vkb_dec_VkImageCreateInfo(d, (VkImageCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: vkb_dec_VkImageDrmFormatModifierExplicitCreateInfoEXT(d, (VkImageDrmFormatModifierExplicitCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: vkb_dec_VkImageDrmFormatModifierListCreateInfoEXT(d, (VkImageDrmFormatModifierListCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: vkb_dec_VkImageDrmFormatModifierPropertiesEXT(d, (VkImageDrmFormatModifierPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: vkb_dec_VkImageFormatListCreateInfo(d, (VkImageFormatListCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: vkb_dec_VkImageFormatProperties2(d, (VkImageFormatProperties2 *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: vkb_dec_VkImageMemoryBarrier(d, (VkImageMemoryBarrier *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: vkb_dec_VkImageMemoryBarrier2(d, (VkImageMemoryBarrier2 *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: vkb_dec_VkImageMemoryRequirementsInfo2(d, (VkImageMemoryRequirementsInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: vkb_dec_VkImagePlaneMemoryRequirementsInfo(d, (VkImagePlaneMemoryRequirementsInfo *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: vkb_dec_VkImageResolve2(d, (VkImageResolve2 *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: vkb_dec_VkImageSparseMemoryRequirementsInfo2(d, (VkImageSparseMemoryRequirementsInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: vkb_dec_VkImageStencilUsageCreateInfo(d, (VkImageStencilUsageCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT: vkb_dec_VkImageSubresource2EXT(d, (VkImageSubresource2EXT *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: vkb_dec_VkImageSwapchainCreateInfoKHR(d, (VkImageSwapchainCreateInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: vkb_dec_VkImageViewASTCDecodeModeEXT(d, (VkImageViewASTCDecodeModeEXT *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: vkb_dec_VkImageViewCreateInfo(d, (VkImageViewCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: vkb_dec_VkImageViewMinLodCreateInfoEXT(d, (VkImageViewMinLodCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: vkb_dec_VkImageViewSlicedCreateInfoEXT(d, (VkImageViewSlicedCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: vkb_dec_VkImageViewUsageCreateInfo(d, (VkImageViewUsageCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: vkb_dec_VkImportFenceFdInfoKHR(d, (VkImportFenceFdInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: vkb_dec_VkImportMemoryFdInfoKHR(d, (VkImportMemoryFdInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: vkb_dec_VkImportSemaphoreFdInfoKHR(d, (VkImportSemaphoreFdInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: vkb_dec_VkInstanceCreateInfo(d, (VkInstanceCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: vkb_dec_VkMappedMemoryRange(d, (VkMappedMemoryRange *)dst); return; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: vkb_dec_VkMemoryAllocateFlagsInfo(d, (VkMemoryAllocateFlagsInfo *)dst); return; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: vkb_dec_VkMemoryAllocateInfo(d, (VkMemoryAllocateInfo *)dst); return; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER: vkb_dec_VkMemoryBarrier(d, (VkMemoryBarrier *)dst); return; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: vkb_dec_VkMemoryBarrier2(d, (VkMemoryBarrier2 *)dst); return; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: vkb_dec_VkMemoryDedicatedAllocateInfo(d, (VkMemoryDedicatedAllocateInfo *)dst); return; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: vkb_dec_VkMemoryDedicatedRequirements(d, (VkMemoryDedicatedRequirements *)dst); return; + case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: vkb_dec_VkMemoryFdPropertiesKHR(d, (VkMemoryFdPropertiesKHR *)dst); return; + case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: vkb_dec_VkMemoryGetFdInfoKHR(d, (VkMemoryGetFdInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: vkb_dec_VkMemoryOpaqueCaptureAddressAllocateInfo(d, (VkMemoryOpaqueCaptureAddressAllocateInfo *)dst); return; + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: vkb_dec_VkMemoryPriorityAllocateInfoEXT(d, (VkMemoryPriorityAllocateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: vkb_dec_VkMemoryRequirements2(d, (VkMemoryRequirements2 *)dst); return; + case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: vkb_dec_VkMultisamplePropertiesEXT(d, (VkMultisamplePropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: vkb_dec_VkMultisampledRenderToSingleSampledInfoEXT(d, (VkMultisampledRenderToSingleSampledInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: vkb_dec_VkMutableDescriptorTypeCreateInfoEXT(d, (VkMutableDescriptorTypeCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: vkb_dec_VkPhysicalDevice16BitStorageFeatures(d, (VkPhysicalDevice16BitStorageFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: vkb_dec_VkPhysicalDevice4444FormatsFeaturesEXT(d, (VkPhysicalDevice4444FormatsFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: vkb_dec_VkPhysicalDevice8BitStorageFeatures(d, (VkPhysicalDevice8BitStorageFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: vkb_dec_VkPhysicalDeviceASTCDecodeFeaturesEXT(d, (VkPhysicalDeviceASTCDecodeFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: vkb_dec_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(d, (VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: vkb_dec_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(d, (VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(d, (VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: vkb_dec_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(d, (VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: vkb_dec_VkPhysicalDeviceBufferDeviceAddressFeatures(d, (VkPhysicalDeviceBufferDeviceAddressFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: vkb_dec_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(d, (VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: vkb_dec_VkPhysicalDeviceColorWriteEnableFeaturesEXT(d, (VkPhysicalDeviceColorWriteEnableFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: vkb_dec_VkPhysicalDeviceConditionalRenderingFeaturesEXT(d, (VkPhysicalDeviceConditionalRenderingFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(d, (VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: vkb_dec_VkPhysicalDeviceCustomBorderColorFeaturesEXT(d, (VkPhysicalDeviceCustomBorderColorFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceCustomBorderColorPropertiesEXT(d, (VkPhysicalDeviceCustomBorderColorPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: vkb_dec_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(d, (VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: vkb_dec_VkPhysicalDeviceDepthClipControlFeaturesEXT(d, (VkPhysicalDeviceDepthClipControlFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: vkb_dec_VkPhysicalDeviceDepthClipEnableFeaturesEXT(d, (VkPhysicalDeviceDepthClipEnableFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: vkb_dec_VkPhysicalDeviceDepthStencilResolveProperties(d, (VkPhysicalDeviceDepthStencilResolveProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: vkb_dec_VkPhysicalDeviceDescriptorIndexingFeatures(d, (VkPhysicalDeviceDescriptorIndexingFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: vkb_dec_VkPhysicalDeviceDescriptorIndexingProperties(d, (VkPhysicalDeviceDescriptorIndexingProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceDiscardRectanglePropertiesEXT(d, (VkPhysicalDeviceDiscardRectanglePropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: vkb_dec_VkPhysicalDeviceDriverProperties(d, (VkPhysicalDeviceDriverProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceDrmPropertiesEXT(d, (VkPhysicalDeviceDrmPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: vkb_dec_VkPhysicalDeviceDynamicRenderingFeatures(d, (VkPhysicalDeviceDynamicRenderingFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: vkb_dec_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(d, (VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: vkb_dec_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(d, (VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(d, (VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: vkb_dec_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(d, (VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: vkb_dec_VkPhysicalDeviceExternalBufferInfo(d, (VkPhysicalDeviceExternalBufferInfo *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: vkb_dec_VkPhysicalDeviceExternalFenceInfo(d, (VkPhysicalDeviceExternalFenceInfo *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: vkb_dec_VkPhysicalDeviceExternalImageFormatInfo(d, (VkPhysicalDeviceExternalImageFormatInfo *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: vkb_dec_VkPhysicalDeviceExternalSemaphoreInfo(d, (VkPhysicalDeviceExternalSemaphoreInfo *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: vkb_dec_VkPhysicalDeviceFeatures2(d, (VkPhysicalDeviceFeatures2 *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: vkb_dec_VkPhysicalDeviceFloatControlsProperties(d, (VkPhysicalDeviceFloatControlsProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: vkb_dec_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(d, (VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(d, (VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: vkb_dec_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(d, (VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(d, (VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: vkb_dec_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(d, (VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: vkb_dec_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(d, (VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: vkb_dec_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(d, (VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: vkb_dec_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(d, (VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: vkb_dec_VkPhysicalDeviceFragmentShadingRateKHR(d, (VkPhysicalDeviceFragmentShadingRateKHR *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: vkb_dec_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(d, (VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: vkb_dec_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(d, (VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: vkb_dec_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(d, (VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(d, (VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: vkb_dec_VkPhysicalDeviceGroupProperties(d, (VkPhysicalDeviceGroupProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: vkb_dec_VkPhysicalDeviceHostQueryResetFeatures(d, (VkPhysicalDeviceHostQueryResetFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: vkb_dec_VkPhysicalDeviceIDProperties(d, (VkPhysicalDeviceIDProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: vkb_dec_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(d, (VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: vkb_dec_VkPhysicalDeviceImageCompressionControlFeaturesEXT(d, (VkPhysicalDeviceImageCompressionControlFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: vkb_dec_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(d, (VkPhysicalDeviceImageDrmFormatModifierInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: vkb_dec_VkPhysicalDeviceImageFormatInfo2(d, (VkPhysicalDeviceImageFormatInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: vkb_dec_VkPhysicalDeviceImageRobustnessFeatures(d, (VkPhysicalDeviceImageRobustnessFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: vkb_dec_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(d, (VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: vkb_dec_VkPhysicalDeviceImageViewImageFormatInfoEXT(d, (VkPhysicalDeviceImageViewImageFormatInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: vkb_dec_VkPhysicalDeviceImageViewMinLodFeaturesEXT(d, (VkPhysicalDeviceImageViewMinLodFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: vkb_dec_VkPhysicalDeviceImagelessFramebufferFeatures(d, (VkPhysicalDeviceImagelessFramebufferFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: vkb_dec_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(d, (VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: vkb_dec_VkPhysicalDeviceInlineUniformBlockFeatures(d, (VkPhysicalDeviceInlineUniformBlockFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: vkb_dec_VkPhysicalDeviceInlineUniformBlockProperties(d, (VkPhysicalDeviceInlineUniformBlockProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: vkb_dec_VkPhysicalDeviceLegacyDitheringFeaturesEXT(d, (VkPhysicalDeviceLegacyDitheringFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: vkb_dec_VkPhysicalDeviceLineRasterizationFeaturesEXT(d, (VkPhysicalDeviceLineRasterizationFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceLineRasterizationPropertiesEXT(d, (VkPhysicalDeviceLineRasterizationPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: vkb_dec_VkPhysicalDeviceMaintenance3Properties(d, (VkPhysicalDeviceMaintenance3Properties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: vkb_dec_VkPhysicalDeviceMaintenance4Features(d, (VkPhysicalDeviceMaintenance4Features *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: vkb_dec_VkPhysicalDeviceMaintenance4Properties(d, (VkPhysicalDeviceMaintenance4Properties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceMemoryBudgetPropertiesEXT(d, (VkPhysicalDeviceMemoryBudgetPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: vkb_dec_VkPhysicalDeviceMemoryPriorityFeaturesEXT(d, (VkPhysicalDeviceMemoryPriorityFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: vkb_dec_VkPhysicalDeviceMemoryProperties2(d, (VkPhysicalDeviceMemoryProperties2 *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: vkb_dec_VkPhysicalDeviceMultiDrawFeaturesEXT(d, (VkPhysicalDeviceMultiDrawFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceMultiDrawPropertiesEXT(d, (VkPhysicalDeviceMultiDrawPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: vkb_dec_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(d, (VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: vkb_dec_VkPhysicalDeviceMultiviewFeatures(d, (VkPhysicalDeviceMultiviewFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: vkb_dec_VkPhysicalDeviceMultiviewProperties(d, (VkPhysicalDeviceMultiviewProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: vkb_dec_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(d, (VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: vkb_dec_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(d, (VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: vkb_dec_VkPhysicalDevicePCIBusInfoPropertiesEXT(d, (VkPhysicalDevicePCIBusInfoPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: vkb_dec_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(d, (VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: vkb_dec_VkPhysicalDevicePipelineCreationCacheControlFeatures(d, (VkPhysicalDevicePipelineCreationCacheControlFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: vkb_dec_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(d, (VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: vkb_dec_VkPhysicalDevicePipelineRobustnessFeaturesEXT(d, (VkPhysicalDevicePipelineRobustnessFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: vkb_dec_VkPhysicalDevicePipelineRobustnessPropertiesEXT(d, (VkPhysicalDevicePipelineRobustnessPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: vkb_dec_VkPhysicalDevicePointClippingProperties(d, (VkPhysicalDevicePointClippingProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: vkb_dec_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(d, (VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: vkb_dec_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(d, (VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: vkb_dec_VkPhysicalDevicePrivateDataFeatures(d, (VkPhysicalDevicePrivateDataFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: vkb_dec_VkPhysicalDeviceProperties2(d, (VkPhysicalDeviceProperties2 *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: vkb_dec_VkPhysicalDeviceProtectedMemoryFeatures(d, (VkPhysicalDeviceProtectedMemoryFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: vkb_dec_VkPhysicalDeviceProtectedMemoryProperties(d, (VkPhysicalDeviceProtectedMemoryProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: vkb_dec_VkPhysicalDeviceProvokingVertexFeaturesEXT(d, (VkPhysicalDeviceProvokingVertexFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceProvokingVertexPropertiesEXT(d, (VkPhysicalDeviceProvokingVertexPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: vkb_dec_VkPhysicalDevicePushDescriptorPropertiesKHR(d, (VkPhysicalDevicePushDescriptorPropertiesKHR *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: vkb_dec_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(d, (VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: vkb_dec_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(d, (VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: vkb_dec_VkPhysicalDeviceRobustness2FeaturesEXT(d, (VkPhysicalDeviceRobustness2FeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceRobustness2PropertiesEXT(d, (VkPhysicalDeviceRobustness2PropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceSampleLocationsPropertiesEXT(d, (VkPhysicalDeviceSampleLocationsPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: vkb_dec_VkPhysicalDeviceSamplerFilterMinmaxProperties(d, (VkPhysicalDeviceSamplerFilterMinmaxProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: vkb_dec_VkPhysicalDeviceSamplerYcbcrConversionFeatures(d, (VkPhysicalDeviceSamplerYcbcrConversionFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: vkb_dec_VkPhysicalDeviceScalarBlockLayoutFeatures(d, (VkPhysicalDeviceScalarBlockLayoutFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: vkb_dec_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(d, (VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: vkb_dec_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(d, (VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: vkb_dec_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(d, (VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: vkb_dec_VkPhysicalDeviceShaderAtomicInt64Features(d, (VkPhysicalDeviceShaderAtomicInt64Features *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: vkb_dec_VkPhysicalDeviceShaderClockFeaturesKHR(d, (VkPhysicalDeviceShaderClockFeaturesKHR *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: vkb_dec_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(d, (VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: vkb_dec_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(d, (VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: vkb_dec_VkPhysicalDeviceShaderCorePropertiesARM(d, (VkPhysicalDeviceShaderCorePropertiesARM *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: vkb_dec_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(d, (VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: vkb_dec_VkPhysicalDeviceShaderDrawParametersFeatures(d, (VkPhysicalDeviceShaderDrawParametersFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: vkb_dec_VkPhysicalDeviceShaderFloat16Int8Features(d, (VkPhysicalDeviceShaderFloat16Int8Features *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: vkb_dec_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(d, (VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: vkb_dec_VkPhysicalDeviceShaderIntegerDotProductFeatures(d, (VkPhysicalDeviceShaderIntegerDotProductFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: vkb_dec_VkPhysicalDeviceShaderIntegerDotProductProperties(d, (VkPhysicalDeviceShaderIntegerDotProductProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: vkb_dec_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(d, (VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(d, (VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: vkb_dec_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(d, (VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: vkb_dec_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(d, (VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: vkb_dec_VkPhysicalDeviceShaderTerminateInvocationFeatures(d, (VkPhysicalDeviceShaderTerminateInvocationFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: vkb_dec_VkPhysicalDeviceShaderTileImageFeaturesEXT(d, (VkPhysicalDeviceShaderTileImageFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceShaderTileImagePropertiesEXT(d, (VkPhysicalDeviceShaderTileImagePropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: vkb_dec_VkPhysicalDeviceSparseImageFormatInfo2(d, (VkPhysicalDeviceSparseImageFormatInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: vkb_dec_VkPhysicalDeviceSubgroupProperties(d, (VkPhysicalDeviceSubgroupProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: vkb_dec_VkPhysicalDeviceSubgroupSizeControlFeatures(d, (VkPhysicalDeviceSubgroupSizeControlFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: vkb_dec_VkPhysicalDeviceSubgroupSizeControlProperties(d, (VkPhysicalDeviceSubgroupSizeControlProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: vkb_dec_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(d, (VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: vkb_dec_VkPhysicalDeviceSynchronization2Features(d, (VkPhysicalDeviceSynchronization2Features *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: vkb_dec_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(d, (VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: vkb_dec_VkPhysicalDeviceTexelBufferAlignmentProperties(d, (VkPhysicalDeviceTexelBufferAlignmentProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: vkb_dec_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(d, (VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: vkb_dec_VkPhysicalDeviceTimelineSemaphoreFeatures(d, (VkPhysicalDeviceTimelineSemaphoreFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: vkb_dec_VkPhysicalDeviceTimelineSemaphoreProperties(d, (VkPhysicalDeviceTimelineSemaphoreProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: vkb_dec_VkPhysicalDeviceToolProperties(d, (VkPhysicalDeviceToolProperties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: vkb_dec_VkPhysicalDeviceTransformFeedbackFeaturesEXT(d, (VkPhysicalDeviceTransformFeedbackFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceTransformFeedbackPropertiesEXT(d, (VkPhysicalDeviceTransformFeedbackPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: vkb_dec_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(d, (VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: vkb_dec_VkPhysicalDeviceVariablePointersFeatures(d, (VkPhysicalDeviceVariablePointersFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: vkb_dec_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(d, (VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: vkb_dec_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(d, (VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: vkb_dec_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(d, (VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: vkb_dec_VkPhysicalDeviceVulkan11Features(d, (VkPhysicalDeviceVulkan11Features *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: vkb_dec_VkPhysicalDeviceVulkan11Properties(d, (VkPhysicalDeviceVulkan11Properties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: vkb_dec_VkPhysicalDeviceVulkan12Features(d, (VkPhysicalDeviceVulkan12Features *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: vkb_dec_VkPhysicalDeviceVulkan12Properties(d, (VkPhysicalDeviceVulkan12Properties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: vkb_dec_VkPhysicalDeviceVulkan13Features(d, (VkPhysicalDeviceVulkan13Features *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: vkb_dec_VkPhysicalDeviceVulkan13Properties(d, (VkPhysicalDeviceVulkan13Properties *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: vkb_dec_VkPhysicalDeviceVulkanMemoryModelFeatures(d, (VkPhysicalDeviceVulkanMemoryModelFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: vkb_dec_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(d, (VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: vkb_dec_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(d, (VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: vkb_dec_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(d, (VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)dst); return; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: vkb_dec_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(d, (VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: vkb_dec_VkPipelineCacheCreateInfo(d, (VkPipelineCacheCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: vkb_dec_VkPipelineColorBlendAdvancedStateCreateInfoEXT(d, (VkPipelineColorBlendAdvancedStateCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: vkb_dec_VkPipelineColorBlendStateCreateInfo(d, (VkPipelineColorBlendStateCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: vkb_dec_VkPipelineColorWriteCreateInfoEXT(d, (VkPipelineColorWriteCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: vkb_dec_VkPipelineCreationFeedbackCreateInfo(d, (VkPipelineCreationFeedbackCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: vkb_dec_VkPipelineDepthStencilStateCreateInfo(d, (VkPipelineDepthStencilStateCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: vkb_dec_VkPipelineDiscardRectangleStateCreateInfoEXT(d, (VkPipelineDiscardRectangleStateCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: vkb_dec_VkPipelineDynamicStateCreateInfo(d, (VkPipelineDynamicStateCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: vkb_dec_VkPipelineFragmentShadingRateStateCreateInfoKHR(d, (VkPipelineFragmentShadingRateStateCreateInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: vkb_dec_VkPipelineInputAssemblyStateCreateInfo(d, (VkPipelineInputAssemblyStateCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: vkb_dec_VkPipelineLayoutCreateInfo(d, (VkPipelineLayoutCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: vkb_dec_VkPipelineLibraryCreateInfoKHR(d, (VkPipelineLibraryCreateInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: vkb_dec_VkPipelineMultisampleStateCreateInfo(d, (VkPipelineMultisampleStateCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: vkb_dec_VkPipelineRasterizationConservativeStateCreateInfoEXT(d, (VkPipelineRasterizationConservativeStateCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: vkb_dec_VkPipelineRasterizationDepthClipStateCreateInfoEXT(d, (VkPipelineRasterizationDepthClipStateCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: vkb_dec_VkPipelineRasterizationLineStateCreateInfoEXT(d, (VkPipelineRasterizationLineStateCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: vkb_dec_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(d, (VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: vkb_dec_VkPipelineRasterizationStateCreateInfo(d, (VkPipelineRasterizationStateCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: vkb_dec_VkPipelineRasterizationStateStreamCreateInfoEXT(d, (VkPipelineRasterizationStateStreamCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: vkb_dec_VkPipelineRenderingCreateInfo(d, (VkPipelineRenderingCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: vkb_dec_VkPipelineRobustnessCreateInfoEXT(d, (VkPipelineRobustnessCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: vkb_dec_VkPipelineSampleLocationsStateCreateInfoEXT(d, (VkPipelineSampleLocationsStateCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: vkb_dec_VkPipelineShaderStageCreateInfo(d, (VkPipelineShaderStageCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: vkb_dec_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(d, (VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: vkb_dec_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(d, (VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: vkb_dec_VkPipelineTessellationDomainOriginStateCreateInfo(d, (VkPipelineTessellationDomainOriginStateCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: vkb_dec_VkPipelineTessellationStateCreateInfo(d, (VkPipelineTessellationStateCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: vkb_dec_VkPipelineVertexInputDivisorStateCreateInfoEXT(d, (VkPipelineVertexInputDivisorStateCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: vkb_dec_VkPipelineVertexInputStateCreateInfo(d, (VkPipelineVertexInputStateCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: vkb_dec_VkPipelineViewportDepthClipControlCreateInfoEXT(d, (VkPipelineViewportDepthClipControlCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: vkb_dec_VkPipelineViewportStateCreateInfo(d, (VkPipelineViewportStateCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: vkb_dec_VkProtectedSubmitInfo(d, (VkProtectedSubmitInfo *)dst); return; + case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: vkb_dec_VkQueryPoolCreateInfo(d, (VkQueryPoolCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: vkb_dec_VkQueueFamilyGlobalPriorityPropertiesKHR(d, (VkQueueFamilyGlobalPriorityPropertiesKHR *)dst); return; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: vkb_dec_VkQueueFamilyProperties2(d, (VkQueueFamilyProperties2 *)dst); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: vkb_dec_VkRenderPassAttachmentBeginInfo(d, (VkRenderPassAttachmentBeginInfo *)dst); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: vkb_dec_VkRenderPassBeginInfo(d, (VkRenderPassBeginInfo *)dst); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: vkb_dec_VkRenderPassCreateInfo(d, (VkRenderPassCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: vkb_dec_VkRenderPassCreateInfo2(d, (VkRenderPassCreateInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: vkb_dec_VkRenderPassCreationControlEXT(d, (VkRenderPassCreationControlEXT *)dst); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: vkb_dec_VkRenderPassCreationFeedbackCreateInfoEXT(d, (VkRenderPassCreationFeedbackCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: vkb_dec_VkRenderPassFragmentDensityMapCreateInfoEXT(d, (VkRenderPassFragmentDensityMapCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: vkb_dec_VkRenderPassInputAttachmentAspectCreateInfo(d, (VkRenderPassInputAttachmentAspectCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: vkb_dec_VkRenderPassMultiviewCreateInfo(d, (VkRenderPassMultiviewCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: vkb_dec_VkRenderPassSampleLocationsBeginInfoEXT(d, (VkRenderPassSampleLocationsBeginInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: vkb_dec_VkRenderPassSubpassFeedbackCreateInfoEXT(d, (VkRenderPassSubpassFeedbackCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: vkb_dec_VkRenderingAttachmentInfo(d, (VkRenderingAttachmentInfo *)dst); return; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: vkb_dec_VkRenderingFragmentDensityMapAttachmentInfoEXT(d, (VkRenderingFragmentDensityMapAttachmentInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: vkb_dec_VkRenderingFragmentShadingRateAttachmentInfoKHR(d, (VkRenderingFragmentShadingRateAttachmentInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_RENDERING_INFO: vkb_dec_VkRenderingInfo(d, (VkRenderingInfo *)dst); return; + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: vkb_dec_VkResolveImageInfo2(d, (VkResolveImageInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: vkb_dec_VkSampleLocationsInfoEXT(d, (VkSampleLocationsInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: vkb_dec_VkSamplerBorderColorComponentMappingCreateInfoEXT(d, (VkSamplerBorderColorComponentMappingCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: vkb_dec_VkSamplerCreateInfo(d, (VkSamplerCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: vkb_dec_VkSamplerCustomBorderColorCreateInfoEXT(d, (VkSamplerCustomBorderColorCreateInfoEXT *)dst); return; + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: vkb_dec_VkSamplerReductionModeCreateInfo(d, (VkSamplerReductionModeCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: vkb_dec_VkSamplerYcbcrConversionCreateInfo(d, (VkSamplerYcbcrConversionCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: vkb_dec_VkSamplerYcbcrConversionImageFormatProperties(d, (VkSamplerYcbcrConversionImageFormatProperties *)dst); return; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: vkb_dec_VkSamplerYcbcrConversionInfo(d, (VkSamplerYcbcrConversionInfo *)dst); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: vkb_dec_VkSemaphoreCreateInfo(d, (VkSemaphoreCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: vkb_dec_VkSemaphoreGetFdInfoKHR(d, (VkSemaphoreGetFdInfoKHR *)dst); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: vkb_dec_VkSemaphoreSignalInfo(d, (VkSemaphoreSignalInfo *)dst); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: vkb_dec_VkSemaphoreSubmitInfo(d, (VkSemaphoreSubmitInfo *)dst); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: vkb_dec_VkSemaphoreTypeCreateInfo(d, (VkSemaphoreTypeCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: vkb_dec_VkSemaphoreWaitInfo(d, (VkSemaphoreWaitInfo *)dst); return; + case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: vkb_dec_VkShaderModuleCreateInfo(d, (VkShaderModuleCreateInfo *)dst); return; + case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: vkb_dec_VkShaderModuleIdentifierEXT(d, (VkShaderModuleIdentifierEXT *)dst); return; + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: vkb_dec_VkSparseImageFormatProperties2(d, (VkSparseImageFormatProperties2 *)dst); return; + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: vkb_dec_VkSparseImageMemoryRequirements2(d, (VkSparseImageMemoryRequirements2 *)dst); return; + case VK_STRUCTURE_TYPE_SUBMIT_INFO: vkb_dec_VkSubmitInfo(d, (VkSubmitInfo *)dst); return; + case VK_STRUCTURE_TYPE_SUBMIT_INFO_2: vkb_dec_VkSubmitInfo2(d, (VkSubmitInfo2 *)dst); return; + case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: vkb_dec_VkSubpassBeginInfo(d, (VkSubpassBeginInfo *)dst); return; + case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: vkb_dec_VkSubpassDependency2(d, (VkSubpassDependency2 *)dst); return; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: vkb_dec_VkSubpassDescription2(d, (VkSubpassDescription2 *)dst); return; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: vkb_dec_VkSubpassDescriptionDepthStencilResolve(d, (VkSubpassDescriptionDepthStencilResolve *)dst); return; + case VK_STRUCTURE_TYPE_SUBPASS_END_INFO: vkb_dec_VkSubpassEndInfo(d, (VkSubpassEndInfo *)dst); return; + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: vkb_dec_VkSubpassResolvePerformanceQueryEXT(d, (VkSubpassResolvePerformanceQueryEXT *)dst); return; + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT: vkb_dec_VkSubresourceLayout2EXT(d, (VkSubresourceLayout2EXT *)dst); return; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: vkb_dec_VkTimelineSemaphoreSubmitInfo(d, (VkTimelineSemaphoreSubmitInfo *)dst); return; + case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: vkb_dec_VkVertexInputAttributeDescription2EXT(d, (VkVertexInputAttributeDescription2EXT *)dst); return; + case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: vkb_dec_VkVertexInputBindingDescription2EXT(d, (VkVertexInputBindingDescription2EXT *)dst); return; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: vkb_dec_VkWriteDescriptorSet(d, (VkWriteDescriptorSet *)dst); return; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: vkb_dec_VkWriteDescriptorSetInlineUniformBlock(d, (VkWriteDescriptorSetInlineUniformBlock *)dst); return; + default: vkb_dec_raw_into(d, dst, vkb_struct_size(t)); return; + } +} + +const char *const vkb_cmd_names[VKB_CMD_COUNT] = { + "vkbHello", + "vkbQueryServer", + "vkbDescUpdateRaw", + "vkbPushDescRaw", + "vkAllocateCommandBuffers", + "vkAllocateDescriptorSets", + "vkAllocateMemory", + "vkBeginCommandBuffer", + "vkBindBufferMemory", + "vkBindBufferMemory2", + "vkBindImageMemory", + "vkBindImageMemory2", + "vkCmdBeginConditionalRenderingEXT", + "vkCmdBeginQuery", + "vkCmdBeginQueryIndexedEXT", + "vkCmdBeginRenderPass", + "vkCmdBeginRenderPass2", + "vkCmdBeginRendering", + "vkCmdBeginTransformFeedbackEXT", + "vkCmdBindDescriptorSets", + "vkCmdBindIndexBuffer", + "vkCmdBindPipeline", + "vkCmdBindTransformFeedbackBuffersEXT", + "vkCmdBindVertexBuffers", + "vkCmdBindVertexBuffers2", + "vkCmdBlitImage", + "vkCmdBlitImage2", + "vkCmdClearAttachments", + "vkCmdClearColorImage", + "vkCmdClearDepthStencilImage", + "vkCmdCopyBuffer", + "vkCmdCopyBuffer2", + "vkCmdCopyBufferToImage", + "vkCmdCopyBufferToImage2", + "vkCmdCopyImage", + "vkCmdCopyImage2", + "vkCmdCopyImageToBuffer", + "vkCmdCopyImageToBuffer2", + "vkCmdCopyQueryPoolResults", + "vkCmdDispatch", + "vkCmdDispatchBase", + "vkCmdDispatchIndirect", + "vkCmdDraw", + "vkCmdDrawIndexed", + "vkCmdDrawIndexedIndirect", + "vkCmdDrawIndexedIndirectCount", + "vkCmdDrawIndirect", + "vkCmdDrawIndirectByteCountEXT", + "vkCmdDrawIndirectCount", + "vkCmdDrawMultiEXT", + "vkCmdDrawMultiIndexedEXT", + "vkCmdEndConditionalRenderingEXT", + "vkCmdEndQuery", + "vkCmdEndQueryIndexedEXT", + "vkCmdEndRenderPass", + "vkCmdEndRenderPass2", + "vkCmdEndRendering", + "vkCmdEndTransformFeedbackEXT", + "vkCmdExecuteCommands", + "vkCmdFillBuffer", + "vkCmdNextSubpass", + "vkCmdNextSubpass2", + "vkCmdPipelineBarrier", + "vkCmdPipelineBarrier2", + "vkCmdPushConstants", + "vkCmdPushDescriptorSetKHR", + "vkCmdResetEvent", + "vkCmdResetEvent2", + "vkCmdResetQueryPool", + "vkCmdResolveImage", + "vkCmdResolveImage2", + "vkCmdSetAlphaToCoverageEnableEXT", + "vkCmdSetAlphaToOneEnableEXT", + "vkCmdSetBlendConstants", + "vkCmdSetColorBlendAdvancedEXT", + "vkCmdSetColorBlendEnableEXT", + "vkCmdSetColorBlendEquationEXT", + "vkCmdSetColorWriteEnableEXT", + "vkCmdSetColorWriteMaskEXT", + "vkCmdSetConservativeRasterizationModeEXT", + "vkCmdSetCoverageModulationModeNV", + "vkCmdSetCoverageModulationTableEnableNV", + "vkCmdSetCoverageModulationTableNV", + "vkCmdSetCoverageReductionModeNV", + "vkCmdSetCoverageToColorEnableNV", + "vkCmdSetCoverageToColorLocationNV", + "vkCmdSetCullMode", + "vkCmdSetDepthBias", + "vkCmdSetDepthBiasEnable", + "vkCmdSetDepthBounds", + "vkCmdSetDepthBoundsTestEnable", + "vkCmdSetDepthClampEnableEXT", + "vkCmdSetDepthClipEnableEXT", + "vkCmdSetDepthClipNegativeOneToOneEXT", + "vkCmdSetDepthCompareOp", + "vkCmdSetDepthTestEnable", + "vkCmdSetDepthWriteEnable", + "vkCmdSetDeviceMask", + "vkCmdSetDiscardRectangleEXT", + "vkCmdSetDiscardRectangleEnableEXT", + "vkCmdSetDiscardRectangleModeEXT", + "vkCmdSetEvent", + "vkCmdSetEvent2", + "vkCmdSetExtraPrimitiveOverestimationSizeEXT", + "vkCmdSetFragmentShadingRateKHR", + "vkCmdSetFrontFace", + "vkCmdSetLineRasterizationModeEXT", + "vkCmdSetLineStippleEXT", + "vkCmdSetLineStippleEnableEXT", + "vkCmdSetLineWidth", + "vkCmdSetLogicOpEXT", + "vkCmdSetLogicOpEnableEXT", + "vkCmdSetPatchControlPointsEXT", + "vkCmdSetPolygonModeEXT", + "vkCmdSetPrimitiveRestartEnable", + "vkCmdSetPrimitiveTopology", + "vkCmdSetProvokingVertexModeEXT", + "vkCmdSetRasterizationSamplesEXT", + "vkCmdSetRasterizationStreamEXT", + "vkCmdSetRasterizerDiscardEnable", + "vkCmdSetRepresentativeFragmentTestEnableNV", + "vkCmdSetSampleLocationsEXT", + "vkCmdSetSampleLocationsEnableEXT", + "vkCmdSetSampleMaskEXT", + "vkCmdSetScissor", + "vkCmdSetScissorWithCount", + "vkCmdSetShadingRateImageEnableNV", + "vkCmdSetStencilCompareMask", + "vkCmdSetStencilOp", + "vkCmdSetStencilReference", + "vkCmdSetStencilTestEnable", + "vkCmdSetStencilWriteMask", + "vkCmdSetTessellationDomainOriginEXT", + "vkCmdSetVertexInputEXT", + "vkCmdSetViewport", + "vkCmdSetViewportSwizzleNV", + "vkCmdSetViewportWScalingEnableNV", + "vkCmdSetViewportWithCount", + "vkCmdUpdateBuffer", + "vkCmdWaitEvents", + "vkCmdWaitEvents2", + "vkCmdWriteTimestamp", + "vkCmdWriteTimestamp2", + "vkCreateBuffer", + "vkCreateBufferView", + "vkCreateCommandPool", + "vkCreateComputePipelines", + "vkCreateDescriptorPool", + "vkCreateDescriptorSetLayout", + "vkCreateDescriptorUpdateTemplate", + "vkCreateDevice", + "vkCreateEvent", + "vkCreateFence", + "vkCreateFramebuffer", + "vkCreateGraphicsPipelines", + "vkCreateImage", + "vkCreateImageView", + "vkCreateInstance", + "vkCreatePipelineCache", + "vkCreatePipelineLayout", + "vkCreateQueryPool", + "vkCreateRenderPass", + "vkCreateRenderPass2", + "vkCreateSampler", + "vkCreateSamplerYcbcrConversion", + "vkCreateSemaphore", + "vkCreateShaderModule", + "vkDestroyBuffer", + "vkDestroyBufferView", + "vkDestroyCommandPool", + "vkDestroyDescriptorPool", + "vkDestroyDescriptorSetLayout", + "vkDestroyDescriptorUpdateTemplate", + "vkDestroyDevice", + "vkDestroyEvent", + "vkDestroyFence", + "vkDestroyFramebuffer", + "vkDestroyImage", + "vkDestroyImageView", + "vkDestroyInstance", + "vkDestroyPipeline", + "vkDestroyPipelineCache", + "vkDestroyPipelineLayout", + "vkDestroyQueryPool", + "vkDestroyRenderPass", + "vkDestroySampler", + "vkDestroySamplerYcbcrConversion", + "vkDestroySemaphore", + "vkDestroyShaderModule", + "vkDeviceWaitIdle", + "vkEndCommandBuffer", + "vkEnumerateDeviceExtensionProperties", + "vkEnumerateInstanceExtensionProperties", + "vkEnumerateInstanceLayerProperties", + "vkEnumerateInstanceVersion", + "vkEnumeratePhysicalDeviceGroups", + "vkEnumeratePhysicalDevices", + "vkFlushMappedMemoryRanges", + "vkFreeCommandBuffers", + "vkFreeDescriptorSets", + "vkFreeMemory", + "vkGetBufferDeviceAddress", + "vkGetBufferMemoryRequirements", + "vkGetBufferMemoryRequirements2", + "vkGetBufferOpaqueCaptureAddress", + "vkGetCalibratedTimestampsEXT", + "vkGetDescriptorSetLayoutSupport", + "vkGetDeviceBufferMemoryRequirements", + "vkGetDeviceGroupPeerMemoryFeatures", + "vkGetDeviceImageMemoryRequirements", + "vkGetDeviceImageSparseMemoryRequirements", + "vkGetDeviceMemoryCommitment", + "vkGetDeviceMemoryOpaqueCaptureAddress", + "vkGetDeviceQueue", + "vkGetDeviceQueue2", + "vkGetEventStatus", + "vkGetFenceFdKHR", + "vkGetFenceStatus", + "vkGetImageDrmFormatModifierPropertiesEXT", + "vkGetImageMemoryRequirements", + "vkGetImageMemoryRequirements2", + "vkGetImageSparseMemoryRequirements", + "vkGetImageSparseMemoryRequirements2", + "vkGetImageSubresourceLayout", + "vkGetImageSubresourceLayout2EXT", + "vkGetMemoryFdKHR", + "vkGetMemoryFdPropertiesKHR", + "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", + "vkGetPhysicalDeviceExternalBufferProperties", + "vkGetPhysicalDeviceExternalFenceProperties", + "vkGetPhysicalDeviceExternalSemaphoreProperties", + "vkGetPhysicalDeviceFeatures", + "vkGetPhysicalDeviceFeatures2", + "vkGetPhysicalDeviceFormatProperties", + "vkGetPhysicalDeviceFormatProperties2", + "vkGetPhysicalDeviceFragmentShadingRatesKHR", + "vkGetPhysicalDeviceImageFormatProperties", + "vkGetPhysicalDeviceImageFormatProperties2", + "vkGetPhysicalDeviceMemoryProperties", + "vkGetPhysicalDeviceMemoryProperties2", + "vkGetPhysicalDeviceMultisamplePropertiesEXT", + "vkGetPhysicalDeviceProperties", + "vkGetPhysicalDeviceProperties2", + "vkGetPhysicalDeviceQueueFamilyProperties", + "vkGetPhysicalDeviceQueueFamilyProperties2", + "vkGetPhysicalDeviceSparseImageFormatProperties", + "vkGetPhysicalDeviceSparseImageFormatProperties2", + "vkGetPhysicalDeviceToolProperties", + "vkGetPipelineCacheData", + "vkGetQueryPoolResults", + "vkGetRenderAreaGranularity", + "vkGetSemaphoreCounterValue", + "vkGetSemaphoreFdKHR", + "vkGetShaderModuleCreateInfoIdentifierEXT", + "vkGetShaderModuleIdentifierEXT", + "vkImportFenceFdKHR", + "vkImportSemaphoreFdKHR", + "vkInvalidateMappedMemoryRanges", + "vkMergePipelineCaches", + "vkQueueBindSparse", + "vkQueueSubmit", + "vkQueueSubmit2", + "vkQueueWaitIdle", + "vkResetCommandBuffer", + "vkResetCommandPool", + "vkResetDescriptorPool", + "vkResetEvent", + "vkResetFences", + "vkResetQueryPool", + "vkSetDeviceMemoryPriorityEXT", + "vkSetEvent", + "vkSignalSemaphore", + "vkTrimCommandPool", + "vkUpdateDescriptorSets", + "vkWaitForFences", + "vkWaitSemaphores", +}; +const vkb_ext_desc vkb_exts[VKB_EXT_COUNT] = { + {"VK_KHR_surface", 0, 1}, + {"VK_KHR_swapchain", 1, 1}, + {"VK_KHR_xlib_surface", 0, 1}, + {"VK_KHR_xcb_surface", 0, 1}, + {"VK_KHR_wayland_surface", 0, 1}, + {"VK_EXT_depth_range_unrestricted", 1, 0}, + {"VK_KHR_sampler_mirror_clamp_to_edge", 1, 0}, + {"VK_IMG_filter_cubic", 1, 0}, + {"VK_EXT_transform_feedback", 1, 0}, + {"VK_KHR_dynamic_rendering", 1, 0}, + {"VK_KHR_multiview", 1, 0}, + {"VK_IMG_format_pvrtc", 1, 0}, + {"VK_KHR_get_physical_device_properties2", 0, 0}, + {"VK_KHR_device_group", 1, 0}, + {"VK_KHR_shader_draw_parameters", 1, 0}, + {"VK_EXT_shader_subgroup_ballot", 1, 0}, + {"VK_EXT_shader_subgroup_vote", 1, 0}, + {"VK_EXT_texture_compression_astc_hdr", 1, 0}, + {"VK_EXT_astc_decode_mode", 1, 0}, + {"VK_EXT_pipeline_robustness", 1, 0}, + {"VK_KHR_maintenance1", 1, 0}, + {"VK_KHR_device_group_creation", 0, 0}, + {"VK_KHR_external_memory_capabilities", 0, 0}, + {"VK_KHR_external_memory", 1, 0}, + {"VK_KHR_external_memory_fd", 1, 0}, + {"VK_KHR_external_semaphore_capabilities", 0, 0}, + {"VK_KHR_external_semaphore", 1, 0}, + {"VK_KHR_external_semaphore_fd", 1, 0}, + {"VK_KHR_push_descriptor", 1, 0}, + {"VK_EXT_conditional_rendering", 1, 0}, + {"VK_KHR_shader_float16_int8", 1, 0}, + {"VK_KHR_16bit_storage", 1, 0}, + {"VK_KHR_incremental_present", 1, 1}, + {"VK_KHR_descriptor_update_template", 1, 0}, + {"VK_EXT_discard_rectangles", 1, 0}, + {"VK_EXT_conservative_rasterization", 1, 0}, + {"VK_EXT_depth_clip_enable", 1, 0}, + {"VK_EXT_swapchain_colorspace", 0, 1}, + {"VK_KHR_imageless_framebuffer", 1, 0}, + {"VK_KHR_create_renderpass2", 1, 0}, + {"VK_KHR_external_fence_capabilities", 0, 0}, + {"VK_KHR_external_fence", 1, 0}, + {"VK_KHR_external_fence_fd", 1, 0}, + {"VK_KHR_maintenance2", 1, 0}, + {"VK_KHR_get_surface_capabilities2", 0, 1}, + {"VK_KHR_variable_pointers", 1, 0}, + {"VK_EXT_external_memory_dma_buf", 1, 0}, + {"VK_EXT_queue_family_foreign", 1, 0}, + {"VK_KHR_dedicated_allocation", 1, 0}, + {"VK_EXT_debug_utils", 0, 1}, + {"VK_EXT_sampler_filter_minmax", 1, 0}, + {"VK_KHR_storage_buffer_storage_class", 1, 0}, + {"VK_EXT_inline_uniform_block", 1, 0}, + {"VK_EXT_shader_stencil_export", 1, 0}, + {"VK_EXT_sample_locations", 1, 0}, + {"VK_KHR_relaxed_block_layout", 1, 0}, + {"VK_KHR_get_memory_requirements2", 1, 0}, + {"VK_KHR_image_format_list", 1, 0}, + {"VK_EXT_blend_operation_advanced", 1, 0}, + {"VK_EXT_post_depth_coverage", 1, 0}, + {"VK_KHR_sampler_ycbcr_conversion", 1, 0}, + {"VK_KHR_bind_memory2", 1, 0}, + {"VK_EXT_image_drm_format_modifier", 1, 0}, + {"VK_EXT_descriptor_indexing", 1, 0}, + {"VK_EXT_shader_viewport_index_layer", 1, 0}, + {"VK_KHR_maintenance3", 1, 0}, + {"VK_KHR_draw_indirect_count", 1, 0}, + {"VK_EXT_filter_cubic", 1, 0}, + {"VK_EXT_global_priority", 1, 0}, + {"VK_KHR_shader_subgroup_extended_types", 1, 0}, + {"VK_KHR_8bit_storage", 1, 0}, + {"VK_KHR_shader_atomic_int64", 1, 0}, + {"VK_KHR_shader_clock", 1, 0}, + {"VK_EXT_calibrated_timestamps", 1, 0}, + {"VK_KHR_global_priority", 1, 0}, + {"VK_EXT_vertex_attribute_divisor", 1, 0}, + {"VK_EXT_pipeline_creation_feedback", 1, 0}, + {"VK_KHR_driver_properties", 1, 0}, + {"VK_KHR_shader_float_controls", 1, 0}, + {"VK_KHR_depth_stencil_resolve", 1, 0}, + {"VK_KHR_swapchain_mutable_format", 1, 1}, + {"VK_KHR_timeline_semaphore", 1, 0}, + {"VK_KHR_vulkan_memory_model", 1, 0}, + {"VK_EXT_pci_bus_info", 1, 0}, + {"VK_KHR_shader_terminate_invocation", 1, 0}, + {"VK_EXT_fragment_density_map", 1, 0}, + {"VK_EXT_scalar_block_layout", 1, 0}, + {"VK_GOOGLE_hlsl_functionality1", 1, 0}, + {"VK_GOOGLE_decorate_string", 1, 0}, + {"VK_EXT_subgroup_size_control", 1, 0}, + {"VK_KHR_fragment_shading_rate", 1, 0}, + {"VK_EXT_shader_image_atomic_int64", 1, 0}, + {"VK_KHR_spirv_1_4", 1, 0}, + {"VK_EXT_memory_budget", 1, 0}, + {"VK_EXT_memory_priority", 1, 0}, + {"VK_KHR_separate_depth_stencil_layouts", 1, 0}, + {"VK_EXT_buffer_device_address", 1, 0}, + {"VK_EXT_tooling_info", 1, 0}, + {"VK_EXT_separate_stencil_usage", 1, 0}, + {"VK_EXT_fragment_shader_interlock", 1, 0}, + {"VK_EXT_ycbcr_image_arrays", 1, 0}, + {"VK_KHR_uniform_buffer_standard_layout", 1, 0}, + {"VK_EXT_provoking_vertex", 1, 0}, + {"VK_EXT_headless_surface", 0, 1}, + {"VK_KHR_buffer_device_address", 1, 0}, + {"VK_EXT_line_rasterization", 1, 0}, + {"VK_EXT_shader_atomic_float", 1, 0}, + {"VK_EXT_host_query_reset", 1, 0}, + {"VK_EXT_index_type_uint8", 1, 0}, + {"VK_EXT_extended_dynamic_state", 1, 0}, + {"VK_KHR_map_memory2", 1, 0}, + {"VK_EXT_shader_atomic_float2", 1, 0}, + {"VK_EXT_shader_demote_to_helper_invocation", 1, 0}, + {"VK_KHR_shader_integer_dot_product", 1, 0}, + {"VK_EXT_texel_buffer_alignment", 1, 0}, + {"VK_EXT_robustness2", 1, 0}, + {"VK_EXT_custom_border_color", 1, 0}, + {"VK_GOOGLE_user_type", 1, 0}, + {"VK_KHR_pipeline_library", 1, 0}, + {"VK_KHR_shader_non_semantic_info", 1, 0}, + {"VK_EXT_private_data", 1, 0}, + {"VK_EXT_pipeline_creation_cache_control", 1, 0}, + {"VK_KHR_synchronization2", 1, 0}, + {"VK_EXT_graphics_pipeline_library", 1, 0}, + {"VK_KHR_fragment_shader_barycentric", 1, 0}, + {"VK_KHR_shader_subgroup_uniform_control_flow", 1, 0}, + {"VK_KHR_zero_initialize_workgroup_memory", 1, 0}, + {"VK_EXT_ycbcr_2plane_444_formats", 1, 0}, + {"VK_EXT_fragment_density_map2", 1, 0}, + {"VK_EXT_image_robustness", 1, 0}, + {"VK_KHR_workgroup_memory_explicit_layout", 1, 0}, + {"VK_KHR_copy_commands2", 1, 0}, + {"VK_EXT_image_compression_control", 1, 0}, + {"VK_EXT_attachment_feedback_loop_layout", 1, 0}, + {"VK_EXT_4444_formats", 1, 0}, + {"VK_ARM_rasterization_order_attachment_access", 1, 0}, + {"VK_EXT_rgba10x6_formats", 1, 0}, + {"VK_VALVE_mutable_descriptor_type", 1, 0}, + {"VK_EXT_vertex_input_dynamic_state", 1, 0}, + {"VK_EXT_physical_device_drm", 1, 0}, + {"VK_EXT_depth_clip_control", 1, 0}, + {"VK_EXT_primitive_topology_list_restart", 1, 0}, + {"VK_KHR_format_feature_flags2", 1, 0}, + {"VK_EXT_multisampled_render_to_single_sampled", 1, 0}, + {"VK_EXT_extended_dynamic_state2", 1, 0}, + {"VK_EXT_color_write_enable", 1, 0}, + {"VK_EXT_primitives_generated_query", 1, 0}, + {"VK_EXT_global_priority_query", 1, 0}, + {"VK_EXT_image_view_min_lod", 1, 0}, + {"VK_EXT_multi_draw", 1, 0}, + {"VK_EXT_image_2d_view_of_3d", 1, 0}, + {"VK_EXT_shader_tile_image", 1, 0}, + {"VK_EXT_load_store_op_none", 1, 0}, + {"VK_EXT_border_color_swizzle", 1, 0}, + {"VK_EXT_pageable_device_local_memory", 1, 0}, + {"VK_KHR_maintenance4", 1, 0}, + {"VK_ARM_shader_core_properties", 1, 0}, + {"VK_EXT_image_sliced_view_of_3d", 1, 0}, + {"VK_EXT_depth_clamp_zero_one", 1, 0}, + {"VK_EXT_non_seamless_cube_map", 1, 0}, + {"VK_GOOGLE_surfaceless_query", 0, 0}, + {"VK_EXT_extended_dynamic_state3", 1, 0}, + {"VK_EXT_subpass_merge_feedback", 1, 0}, + {"VK_EXT_shader_module_identifier", 1, 0}, + {"VK_EXT_rasterization_order_attachment_access", 1, 0}, + {"VK_EXT_legacy_dithering", 1, 0}, + {"VK_EXT_pipeline_protected_access", 1, 0}, + {"VK_EXT_mutable_descriptor_type", 1, 0}, + {"VK_ARM_shader_core_builtins", 1, 0}, +}; diff --git a/tools/vkbridge/common/gen/vkb_server_gen.h b/tools/vkbridge/common/gen/vkb_server_gen.h new file mode 100644 index 000000000..0906eeaad --- /dev/null +++ b/tools/vkbridge/common/gen/vkb_server_gen.h @@ -0,0 +1,285 @@ +/* Generated by tools/vkbridge/codegen/gen_vkbridge.py from vk.xml 1.3.247 - do not edit. */ + +#ifndef VKB_SERVER_GEN_H +#define VKB_SERVER_GEN_H +#include "vkb_gen.h" +typedef struct vkb_srv_call vkb_srv_call; +typedef void (*vkb_srv_handler)(vkb_srv_call *c); +extern const vkb_srv_handler vkb_srv_handlers[VKB_CMD_COUNT]; +void vkb_sv_vkAllocateCommandBuffers(vkb_srv_call *c); +void vkb_sv_vkAllocateDescriptorSets(vkb_srv_call *c); +void vkb_sv_vkAllocateMemory(vkb_srv_call *c); +void vkb_sv_vkBeginCommandBuffer(vkb_srv_call *c); +void vkb_sv_vkBindBufferMemory(vkb_srv_call *c); +void vkb_sv_vkBindBufferMemory2(vkb_srv_call *c); +void vkb_sv_vkBindImageMemory(vkb_srv_call *c); +void vkb_sv_vkBindImageMemory2(vkb_srv_call *c); +void vkb_sv_vkCmdBeginConditionalRenderingEXT(vkb_srv_call *c); +void vkb_sv_vkCmdBeginQuery(vkb_srv_call *c); +void vkb_sv_vkCmdBeginQueryIndexedEXT(vkb_srv_call *c); +void vkb_sv_vkCmdBeginRenderPass(vkb_srv_call *c); +void vkb_sv_vkCmdBeginRenderPass2(vkb_srv_call *c); +void vkb_sv_vkCmdBeginRendering(vkb_srv_call *c); +void vkb_sv_vkCmdBeginTransformFeedbackEXT(vkb_srv_call *c); +void vkb_sv_vkCmdBindDescriptorSets(vkb_srv_call *c); +void vkb_sv_vkCmdBindIndexBuffer(vkb_srv_call *c); +void vkb_sv_vkCmdBindPipeline(vkb_srv_call *c); +void vkb_sv_vkCmdBindTransformFeedbackBuffersEXT(vkb_srv_call *c); +void vkb_sv_vkCmdBindVertexBuffers(vkb_srv_call *c); +void vkb_sv_vkCmdBindVertexBuffers2(vkb_srv_call *c); +void vkb_sv_vkCmdBlitImage(vkb_srv_call *c); +void vkb_sv_vkCmdBlitImage2(vkb_srv_call *c); +void vkb_sv_vkCmdClearAttachments(vkb_srv_call *c); +void vkb_sv_vkCmdClearColorImage(vkb_srv_call *c); +void vkb_sv_vkCmdClearDepthStencilImage(vkb_srv_call *c); +void vkb_sv_vkCmdCopyBuffer(vkb_srv_call *c); +void vkb_sv_vkCmdCopyBuffer2(vkb_srv_call *c); +void vkb_sv_vkCmdCopyBufferToImage(vkb_srv_call *c); +void vkb_sv_vkCmdCopyBufferToImage2(vkb_srv_call *c); +void vkb_sv_vkCmdCopyImage(vkb_srv_call *c); +void vkb_sv_vkCmdCopyImage2(vkb_srv_call *c); +void vkb_sv_vkCmdCopyImageToBuffer(vkb_srv_call *c); +void vkb_sv_vkCmdCopyImageToBuffer2(vkb_srv_call *c); +void vkb_sv_vkCmdCopyQueryPoolResults(vkb_srv_call *c); +void vkb_sv_vkCmdDispatch(vkb_srv_call *c); +void vkb_sv_vkCmdDispatchBase(vkb_srv_call *c); +void vkb_sv_vkCmdDispatchIndirect(vkb_srv_call *c); +void vkb_sv_vkCmdDraw(vkb_srv_call *c); +void vkb_sv_vkCmdDrawIndexed(vkb_srv_call *c); +void vkb_sv_vkCmdDrawIndexedIndirect(vkb_srv_call *c); +void vkb_sv_vkCmdDrawIndexedIndirectCount(vkb_srv_call *c); +void vkb_sv_vkCmdDrawIndirect(vkb_srv_call *c); +void vkb_sv_vkCmdDrawIndirectByteCountEXT(vkb_srv_call *c); +void vkb_sv_vkCmdDrawIndirectCount(vkb_srv_call *c); +void vkb_sv_vkCmdDrawMultiEXT(vkb_srv_call *c); +void vkb_sv_vkCmdDrawMultiIndexedEXT(vkb_srv_call *c); +void vkb_sv_vkCmdEndConditionalRenderingEXT(vkb_srv_call *c); +void vkb_sv_vkCmdEndQuery(vkb_srv_call *c); +void vkb_sv_vkCmdEndQueryIndexedEXT(vkb_srv_call *c); +void vkb_sv_vkCmdEndRenderPass(vkb_srv_call *c); +void vkb_sv_vkCmdEndRenderPass2(vkb_srv_call *c); +void vkb_sv_vkCmdEndRendering(vkb_srv_call *c); +void vkb_sv_vkCmdEndTransformFeedbackEXT(vkb_srv_call *c); +void vkb_sv_vkCmdExecuteCommands(vkb_srv_call *c); +void vkb_sv_vkCmdFillBuffer(vkb_srv_call *c); +void vkb_sv_vkCmdNextSubpass(vkb_srv_call *c); +void vkb_sv_vkCmdNextSubpass2(vkb_srv_call *c); +void vkb_sv_vkCmdPipelineBarrier(vkb_srv_call *c); +void vkb_sv_vkCmdPipelineBarrier2(vkb_srv_call *c); +void vkb_sv_vkCmdPushConstants(vkb_srv_call *c); +void vkb_sv_vkCmdPushDescriptorSetKHR(vkb_srv_call *c); +void vkb_sv_vkCmdResetEvent(vkb_srv_call *c); +void vkb_sv_vkCmdResetEvent2(vkb_srv_call *c); +void vkb_sv_vkCmdResetQueryPool(vkb_srv_call *c); +void vkb_sv_vkCmdResolveImage(vkb_srv_call *c); +void vkb_sv_vkCmdResolveImage2(vkb_srv_call *c); +void vkb_sv_vkCmdSetAlphaToCoverageEnableEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetAlphaToOneEnableEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetBlendConstants(vkb_srv_call *c); +void vkb_sv_vkCmdSetColorBlendAdvancedEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetColorBlendEnableEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetColorBlendEquationEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetColorWriteEnableEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetColorWriteMaskEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetConservativeRasterizationModeEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetCoverageModulationModeNV(vkb_srv_call *c); +void vkb_sv_vkCmdSetCoverageModulationTableEnableNV(vkb_srv_call *c); +void vkb_sv_vkCmdSetCoverageModulationTableNV(vkb_srv_call *c); +void vkb_sv_vkCmdSetCoverageReductionModeNV(vkb_srv_call *c); +void vkb_sv_vkCmdSetCoverageToColorEnableNV(vkb_srv_call *c); +void vkb_sv_vkCmdSetCoverageToColorLocationNV(vkb_srv_call *c); +void vkb_sv_vkCmdSetCullMode(vkb_srv_call *c); +void vkb_sv_vkCmdSetDepthBias(vkb_srv_call *c); +void vkb_sv_vkCmdSetDepthBiasEnable(vkb_srv_call *c); +void vkb_sv_vkCmdSetDepthBounds(vkb_srv_call *c); +void vkb_sv_vkCmdSetDepthBoundsTestEnable(vkb_srv_call *c); +void vkb_sv_vkCmdSetDepthClampEnableEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetDepthClipEnableEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetDepthClipNegativeOneToOneEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetDepthCompareOp(vkb_srv_call *c); +void vkb_sv_vkCmdSetDepthTestEnable(vkb_srv_call *c); +void vkb_sv_vkCmdSetDepthWriteEnable(vkb_srv_call *c); +void vkb_sv_vkCmdSetDeviceMask(vkb_srv_call *c); +void vkb_sv_vkCmdSetDiscardRectangleEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetDiscardRectangleEnableEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetDiscardRectangleModeEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetEvent(vkb_srv_call *c); +void vkb_sv_vkCmdSetEvent2(vkb_srv_call *c); +void vkb_sv_vkCmdSetExtraPrimitiveOverestimationSizeEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetFragmentShadingRateKHR(vkb_srv_call *c); +void vkb_sv_vkCmdSetFrontFace(vkb_srv_call *c); +void vkb_sv_vkCmdSetLineRasterizationModeEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetLineStippleEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetLineStippleEnableEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetLineWidth(vkb_srv_call *c); +void vkb_sv_vkCmdSetLogicOpEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetLogicOpEnableEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetPatchControlPointsEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetPolygonModeEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetPrimitiveRestartEnable(vkb_srv_call *c); +void vkb_sv_vkCmdSetPrimitiveTopology(vkb_srv_call *c); +void vkb_sv_vkCmdSetProvokingVertexModeEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetRasterizationSamplesEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetRasterizationStreamEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetRasterizerDiscardEnable(vkb_srv_call *c); +void vkb_sv_vkCmdSetRepresentativeFragmentTestEnableNV(vkb_srv_call *c); +void vkb_sv_vkCmdSetSampleLocationsEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetSampleLocationsEnableEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetSampleMaskEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetScissor(vkb_srv_call *c); +void vkb_sv_vkCmdSetScissorWithCount(vkb_srv_call *c); +void vkb_sv_vkCmdSetShadingRateImageEnableNV(vkb_srv_call *c); +void vkb_sv_vkCmdSetStencilCompareMask(vkb_srv_call *c); +void vkb_sv_vkCmdSetStencilOp(vkb_srv_call *c); +void vkb_sv_vkCmdSetStencilReference(vkb_srv_call *c); +void vkb_sv_vkCmdSetStencilTestEnable(vkb_srv_call *c); +void vkb_sv_vkCmdSetStencilWriteMask(vkb_srv_call *c); +void vkb_sv_vkCmdSetTessellationDomainOriginEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetVertexInputEXT(vkb_srv_call *c); +void vkb_sv_vkCmdSetViewport(vkb_srv_call *c); +void vkb_sv_vkCmdSetViewportSwizzleNV(vkb_srv_call *c); +void vkb_sv_vkCmdSetViewportWScalingEnableNV(vkb_srv_call *c); +void vkb_sv_vkCmdSetViewportWithCount(vkb_srv_call *c); +void vkb_sv_vkCmdUpdateBuffer(vkb_srv_call *c); +void vkb_sv_vkCmdWaitEvents(vkb_srv_call *c); +void vkb_sv_vkCmdWaitEvents2(vkb_srv_call *c); +void vkb_sv_vkCmdWriteTimestamp(vkb_srv_call *c); +void vkb_sv_vkCmdWriteTimestamp2(vkb_srv_call *c); +void vkb_sv_vkCreateBuffer(vkb_srv_call *c); +void vkb_sv_vkCreateBufferView(vkb_srv_call *c); +void vkb_sv_vkCreateCommandPool(vkb_srv_call *c); +void vkb_sv_vkCreateComputePipelines(vkb_srv_call *c); +void vkb_sv_vkCreateDescriptorPool(vkb_srv_call *c); +void vkb_sv_vkCreateDescriptorSetLayout(vkb_srv_call *c); +void vkb_sv_vkCreateDescriptorUpdateTemplate(vkb_srv_call *c); +void vkb_sv_vkCreateDevice(vkb_srv_call *c); +void vkb_sv_vkCreateEvent(vkb_srv_call *c); +void vkb_sv_vkCreateFence(vkb_srv_call *c); +void vkb_sv_vkCreateFramebuffer(vkb_srv_call *c); +void vkb_sv_vkCreateGraphicsPipelines(vkb_srv_call *c); +void vkb_sv_vkCreateImage(vkb_srv_call *c); +void vkb_sv_vkCreateImageView(vkb_srv_call *c); +void vkb_sv_vkCreateInstance(vkb_srv_call *c); +void vkb_sv_vkCreatePipelineCache(vkb_srv_call *c); +void vkb_sv_vkCreatePipelineLayout(vkb_srv_call *c); +void vkb_sv_vkCreateQueryPool(vkb_srv_call *c); +void vkb_sv_vkCreateRenderPass(vkb_srv_call *c); +void vkb_sv_vkCreateRenderPass2(vkb_srv_call *c); +void vkb_sv_vkCreateSampler(vkb_srv_call *c); +void vkb_sv_vkCreateSamplerYcbcrConversion(vkb_srv_call *c); +void vkb_sv_vkCreateSemaphore(vkb_srv_call *c); +void vkb_sv_vkCreateShaderModule(vkb_srv_call *c); +void vkb_sv_vkDestroyBuffer(vkb_srv_call *c); +void vkb_sv_vkDestroyBufferView(vkb_srv_call *c); +void vkb_sv_vkDestroyCommandPool(vkb_srv_call *c); +void vkb_sv_vkDestroyDescriptorPool(vkb_srv_call *c); +void vkb_sv_vkDestroyDescriptorSetLayout(vkb_srv_call *c); +void vkb_sv_vkDestroyDescriptorUpdateTemplate(vkb_srv_call *c); +void vkb_sv_vkDestroyDevice(vkb_srv_call *c); +void vkb_sv_vkDestroyEvent(vkb_srv_call *c); +void vkb_sv_vkDestroyFence(vkb_srv_call *c); +void vkb_sv_vkDestroyFramebuffer(vkb_srv_call *c); +void vkb_sv_vkDestroyImage(vkb_srv_call *c); +void vkb_sv_vkDestroyImageView(vkb_srv_call *c); +void vkb_sv_vkDestroyInstance(vkb_srv_call *c); +void vkb_sv_vkDestroyPipeline(vkb_srv_call *c); +void vkb_sv_vkDestroyPipelineCache(vkb_srv_call *c); +void vkb_sv_vkDestroyPipelineLayout(vkb_srv_call *c); +void vkb_sv_vkDestroyQueryPool(vkb_srv_call *c); +void vkb_sv_vkDestroyRenderPass(vkb_srv_call *c); +void vkb_sv_vkDestroySampler(vkb_srv_call *c); +void vkb_sv_vkDestroySamplerYcbcrConversion(vkb_srv_call *c); +void vkb_sv_vkDestroySemaphore(vkb_srv_call *c); +void vkb_sv_vkDestroyShaderModule(vkb_srv_call *c); +void vkb_sv_vkDeviceWaitIdle(vkb_srv_call *c); +void vkb_sv_vkEndCommandBuffer(vkb_srv_call *c); +void vkb_sv_vkEnumerateDeviceExtensionProperties(vkb_srv_call *c); +void vkb_sv_vkEnumerateInstanceExtensionProperties(vkb_srv_call *c); +void vkb_sv_vkEnumerateInstanceLayerProperties(vkb_srv_call *c); +void vkb_sv_vkEnumerateInstanceVersion(vkb_srv_call *c); +void vkb_sv_vkEnumeratePhysicalDeviceGroups(vkb_srv_call *c); +void vkb_sv_vkEnumeratePhysicalDevices(vkb_srv_call *c); +void vkb_sv_vkFlushMappedMemoryRanges(vkb_srv_call *c); +void vkb_sv_vkFreeCommandBuffers(vkb_srv_call *c); +void vkb_sv_vkFreeDescriptorSets(vkb_srv_call *c); +void vkb_sv_vkFreeMemory(vkb_srv_call *c); +void vkb_sv_vkGetBufferDeviceAddress(vkb_srv_call *c); +void vkb_sv_vkGetBufferMemoryRequirements(vkb_srv_call *c); +void vkb_sv_vkGetBufferMemoryRequirements2(vkb_srv_call *c); +void vkb_sv_vkGetBufferOpaqueCaptureAddress(vkb_srv_call *c); +void vkb_sv_vkGetCalibratedTimestampsEXT(vkb_srv_call *c); +void vkb_sv_vkGetDescriptorSetLayoutSupport(vkb_srv_call *c); +void vkb_sv_vkGetDeviceBufferMemoryRequirements(vkb_srv_call *c); +void vkb_sv_vkGetDeviceGroupPeerMemoryFeatures(vkb_srv_call *c); +void vkb_sv_vkGetDeviceImageMemoryRequirements(vkb_srv_call *c); +void vkb_sv_vkGetDeviceImageSparseMemoryRequirements(vkb_srv_call *c); +void vkb_sv_vkGetDeviceMemoryCommitment(vkb_srv_call *c); +void vkb_sv_vkGetDeviceMemoryOpaqueCaptureAddress(vkb_srv_call *c); +void vkb_sv_vkGetDeviceQueue(vkb_srv_call *c); +void vkb_sv_vkGetDeviceQueue2(vkb_srv_call *c); +void vkb_sv_vkGetEventStatus(vkb_srv_call *c); +void vkb_sv_vkGetFenceFdKHR(vkb_srv_call *c); +void vkb_sv_vkGetFenceStatus(vkb_srv_call *c); +void vkb_sv_vkGetImageDrmFormatModifierPropertiesEXT(vkb_srv_call *c); +void vkb_sv_vkGetImageMemoryRequirements(vkb_srv_call *c); +void vkb_sv_vkGetImageMemoryRequirements2(vkb_srv_call *c); +void vkb_sv_vkGetImageSparseMemoryRequirements(vkb_srv_call *c); +void vkb_sv_vkGetImageSparseMemoryRequirements2(vkb_srv_call *c); +void vkb_sv_vkGetImageSubresourceLayout(vkb_srv_call *c); +void vkb_sv_vkGetImageSubresourceLayout2EXT(vkb_srv_call *c); +void vkb_sv_vkGetMemoryFdKHR(vkb_srv_call *c); +void vkb_sv_vkGetMemoryFdPropertiesKHR(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceExternalBufferProperties(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceExternalFenceProperties(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceExternalSemaphoreProperties(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceFeatures(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceFeatures2(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceFormatProperties(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceFormatProperties2(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceFragmentShadingRatesKHR(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceImageFormatProperties(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceImageFormatProperties2(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceMemoryProperties(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceMemoryProperties2(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceMultisamplePropertiesEXT(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceProperties(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceProperties2(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceQueueFamilyProperties(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceQueueFamilyProperties2(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceSparseImageFormatProperties(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceSparseImageFormatProperties2(vkb_srv_call *c); +void vkb_sv_vkGetPhysicalDeviceToolProperties(vkb_srv_call *c); +void vkb_sv_vkGetPipelineCacheData(vkb_srv_call *c); +void vkb_sv_vkGetQueryPoolResults(vkb_srv_call *c); +void vkb_sv_vkGetRenderAreaGranularity(vkb_srv_call *c); +void vkb_sv_vkGetSemaphoreCounterValue(vkb_srv_call *c); +void vkb_sv_vkGetSemaphoreFdKHR(vkb_srv_call *c); +void vkb_sv_vkGetShaderModuleCreateInfoIdentifierEXT(vkb_srv_call *c); +void vkb_sv_vkGetShaderModuleIdentifierEXT(vkb_srv_call *c); +void vkb_sv_vkImportFenceFdKHR(vkb_srv_call *c); +void vkb_sv_vkImportSemaphoreFdKHR(vkb_srv_call *c); +void vkb_sv_vkInvalidateMappedMemoryRanges(vkb_srv_call *c); +void vkb_sv_vkMergePipelineCaches(vkb_srv_call *c); +void vkb_sv_vkQueueBindSparse(vkb_srv_call *c); +void vkb_sv_vkQueueSubmit(vkb_srv_call *c); +void vkb_sv_vkQueueSubmit2(vkb_srv_call *c); +void vkb_sv_vkQueueWaitIdle(vkb_srv_call *c); +void vkb_sv_vkResetCommandBuffer(vkb_srv_call *c); +void vkb_sv_vkResetCommandPool(vkb_srv_call *c); +void vkb_sv_vkResetDescriptorPool(vkb_srv_call *c); +void vkb_sv_vkResetEvent(vkb_srv_call *c); +void vkb_sv_vkResetFences(vkb_srv_call *c); +void vkb_sv_vkResetQueryPool(vkb_srv_call *c); +void vkb_sv_vkSetDeviceMemoryPriorityEXT(vkb_srv_call *c); +void vkb_sv_vkSetEvent(vkb_srv_call *c); +void vkb_sv_vkSignalSemaphore(vkb_srv_call *c); +void vkb_sv_vkTrimCommandPool(vkb_srv_call *c); +void vkb_sv_vkUpdateDescriptorSets(vkb_srv_call *c); +void vkb_sv_vkWaitForFences(vkb_srv_call *c); +void vkb_sv_vkWaitSemaphores(vkb_srv_call *c); +void vkb_sv_vkbHello(vkb_srv_call *c); +void vkb_sv_vkbQueryServer(vkb_srv_call *c); +void vkb_sv_vkbDescUpdateRaw(vkb_srv_call *c); +void vkb_sv_vkbPushDescRaw(vkb_srv_call *c); +#endif diff --git a/tools/vkbridge/common/vkb_log.h b/tools/vkbridge/common/vkb_log.h new file mode 100644 index 000000000..a84b272db --- /dev/null +++ b/tools/vkbridge/common/vkb_log.h @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later */ +#ifndef VKB_LOG_H +#define VKB_LOG_H + +#include + +#define VKB_LOG_ERROR 0 +#define VKB_LOG_WARN 1 +#define VKB_LOG_INFO 2 +#define VKB_LOG_DEBUG 3 + +/* Each side provides the sink (client: stderr + optional file; server: logcat + file). */ +void vkb_log(int level, const char *fmt, ...) __attribute__((format(printf, 2, 3))); +int vkb_log_level(void); + +#define VKB_ERR(...) vkb_log(VKB_LOG_ERROR, __VA_ARGS__) +#define VKB_WARN(...) vkb_log(VKB_LOG_WARN, __VA_ARGS__) +#define VKB_INFO(...) vkb_log(VKB_LOG_INFO, __VA_ARGS__) +#define VKB_DBG(...) do { if (vkb_log_level() >= VKB_LOG_DEBUG) vkb_log(VKB_LOG_DEBUG, __VA_ARGS__); } while (0) + +/* Logs a message only the first time this call site is reached. */ +#define VKB_ONCE(level, ...) do { static int once_; if (!__atomic_exchange_n(&once_, 1, __ATOMIC_RELAXED)) vkb_log(level, __VA_ARGS__); } while (0) + +#endif diff --git a/tools/vkbridge/common/vkb_proto.h b/tools/vkbridge/common/vkb_proto.h new file mode 100644 index 000000000..375e2f2e5 --- /dev/null +++ b/tools/vkbridge/common/vkb_proto.h @@ -0,0 +1,58 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Bridge-specific (non-Vulkan) parts of the protocol: hello, server query, memory sharing. + */ +#ifndef VKB_PROTO_H +#define VKB_PROTO_H + +#include + +#define VKB_DEFAULT_SOCKET_ENV "VKBRIDGE_SOCKET" + +/* How host-visible memory is shared between the client's address space and the GPU. */ +enum vkb_mem_strategy { + VKB_MEM_NONE = 0, /* no sharing works: host-visible memory is not offered */ + VKB_MEM_HOSTPTR = 1, /* client memfd, server imports it (VK_EXT_external_memory_host) */ + VKB_MEM_DMABUF = 2, /* server exports a dma-buf (VK_EXT_external_memory_dma_buf), client mmaps */ + VKB_MEM_AHB = 3, /* server allocates an AHardwareBuffer (BLOB), client mmaps its dma-buf */ +}; + +static inline const char *vkb_mem_strategy_name(uint32_t s) +{ + switch (s) { + case VKB_MEM_HOSTPTR: return "hostptr"; + case VKB_MEM_DMABUF: return "dmabuf"; + case VKB_MEM_AHB: return "ahb"; + default: return "none"; + } +} + +/* Emulated features (server rewrites resources/shaders; client reports them as supported). */ +#define VKB_EMU_BCN (1u << 0) /* BC1-BC7 textures decoded on upload */ +#define VKB_EMU_DIVISOR (1u << 1) /* VK_EXT_vertex_attribute_divisor */ +#define VKB_EMU_CLIP_DISTANCE (1u << 2) /* shaderClipDistance */ +#define VKB_EMU_CULL_DISTANCE (1u << 3) /* shaderCullDistance (accepted, not applied) */ +#define VKB_EMU_POINT_SIZE (1u << 4) /* strip PointSize from geometry/tessellation stages */ +#define VKB_EMU_DEPTH_CLIP (1u << 5) /* VK_EXT_depth_clip_enable via depthClamp */ + +/* vkbQueryServer reply (per physical device). */ +typedef struct vkb_server_pd_info { + uint32_t strategy; /* enum vkb_mem_strategy */ + uint32_t buffer_handle_types; /* VkExternalMemoryHandleTypeFlags to put on buffers */ + uint32_t shareable_types; /* server memory type bits that can be shared */ + uint32_t coherent_types; /* of those, verified coherent without flushes */ + uint64_t import_alignment; /* hostptr: minImportedHostPointerAlignment */ + uint32_t emu; /* VKB_EMU_* the server will perform */ + uint32_t emu_available; /* VKB_EMU_* the server could perform */ + uint32_t real_api_version; + uint32_t reserved[7]; +} vkb_server_pd_info; + +/* vkAllocateMemory wire extras (after VkMemoryAllocateInfo). */ +#define VKB_ALLOC_PLAIN 0u +#define VKB_ALLOC_SHARED 1u + +/* Extra structure the client hangs on create infos to tell the server which shared handle + * types were injected (so the server can remove them if the driver refuses). Not on the wire. */ + +#endif diff --git a/tools/vkbridge/common/vkb_server_iface.h b/tools/vkbridge/common/vkb_server_iface.h new file mode 100644 index 000000000..ccc922867 --- /dev/null +++ b/tools/vkbridge/common/vkb_server_iface.h @@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * What the generated server handlers need from the server: the per-call context. + */ +#ifndef VKB_SERVER_IFACE_H +#define VKB_SERVER_IFACE_H + +#include "vkb_wire.h" + +struct vkb_srv_table; +struct vkb_srv_conn; + +struct vkb_srv_call { + vkb_dec d; /* request */ + vkb_enc r; /* reply payload */ + vkb_dispatch *dt; /* dispatch for the table named in the request */ + struct vkb_srv_table *table; /* NULL for global commands */ + struct vkb_srv_conn *conn; + uint32_t status; /* reply status (VKB_ST_*) */ + int close_after[VKB_MAX_FDS]; /* server fds to close once the reply is sent */ + int nclose; + int in_stream; /* replaying a command buffer stream */ +}; + +void vkb_srv_bad_message(struct vkb_srv_call *c); +void vkb_srv_missing(struct vkb_srv_call *c, const char *name); +void vkb_srv_close_after_send(struct vkb_srv_call *c, int fd); + +#endif diff --git a/tools/vkbridge/common/vkb_wire.c b/tools/vkbridge/common/vkb_wire.c new file mode 100644 index 000000000..de63aede6 --- /dev/null +++ b/tools/vkbridge/common/vkb_wire.c @@ -0,0 +1,691 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later */ +#include "vkb_wire.h" +#include "vkb_log.h" + +#include +#include +#include +#include +#include +#include + +/* ------------------------------------------------------------------ arena */ + +struct vkb_arena_block { + vkb_arena_block *next; + size_t used, cap; + /* data follows, 16-aligned */ +}; + +#define ARENA_HDR ((sizeof(vkb_arena_block) + 15) & ~(size_t)15) + +void *vkb_arena_alloc(vkb_arena *a, size_t n) +{ + n = (n + 15) & ~(size_t)15; + if (n == 0) n = 16; + vkb_arena_block *b = a->head; + if (!b || b->cap - b->used < n) { + size_t cap = n > 65536 ? n : 65536; + b = malloc(ARENA_HDR + cap); + if (!b) return NULL; + b->next = a->head; + b->used = 0; + b->cap = cap; + a->head = b; + } + void *p = (uint8_t *)b + ARENA_HDR + b->used; + b->used += n; + a->used_total += n; + memset(p, 0, n); + return p; +} + +void vkb_arena_reset(vkb_arena *a) +{ + /* Keep the most recent block if it is the default size; free the rest. */ + vkb_arena_block *b = a->head, *keep = NULL; + while (b) { + vkb_arena_block *n = b->next; + if (!keep && b->cap == 65536) { + keep = b; + keep->next = NULL; + keep->used = 0; + } else { + free(b); + } + b = n; + } + a->head = keep; + a->used_total = 0; +} + +void vkb_arena_free(vkb_arena *a) +{ + vkb_arena_block *b = a->head; + while (b) { + vkb_arena_block *n = b->next; + free(b); + b = n; + } + a->head = NULL; +} + +/* ------------------------------------------------------------------ encoder */ + +void vkb_enc_init(vkb_enc *e) +{ + memset(e, 0, sizeof(*e)); +} + +void vkb_enc_reset(vkb_enc *e) +{ + e->len = 0; + e->nfds = 0; + e->oom = 0; +} + +void vkb_enc_free(vkb_enc *e) +{ + free(e->buf); + memset(e, 0, sizeof(*e)); +} + +static int enc_grow(vkb_enc *e, size_t add) +{ + if (e->oom) return 0; + size_t need = e->len + add; + if (need <= e->cap) return 1; + size_t cap = e->cap ? e->cap : 4096; + while (cap < need) cap *= 2; + uint8_t *nb = realloc(e->buf, cap); + if (!nb) { + e->oom = 1; + return 0; + } + e->buf = nb; + e->cap = cap; + return 1; +} + +void vkb_enc_bytes(vkb_enc *e, const void *p, size_t n) +{ + if (!n || !enc_grow(e, n)) return; + if (p) memcpy(e->buf + e->len, p, n); + else memset(e->buf + e->len, 0, n); + e->len += n; +} + +void vkb_enc_u8(vkb_enc *e, uint8_t v) { vkb_enc_bytes(e, &v, 1); } +void vkb_enc_u32(vkb_enc *e, uint32_t v) { vkb_enc_bytes(e, &v, 4); } +void vkb_enc_u64(vkb_enc *e, uint64_t v) { vkb_enc_bytes(e, &v, 8); } + +static void enc_align(vkb_enc *e) +{ + size_t pad = (8 - (e->len & 7)) & 7; + if (pad) vkb_enc_bytes(e, NULL, pad); +} + +size_t vkb_enc_raw(vkb_enc *e, const void *p, size_t n) +{ + enc_align(e); + size_t off = e->len; + vkb_enc_bytes(e, p, n); + return off; +} + +void vkb_enc_patch_u64(vkb_enc *e, size_t off, uint64_t v) +{ + if (e->oom || off + 8 > e->len) return; + memcpy(e->buf + off, &v, 8); +} + +void vkb_enc_str(vkb_enc *e, const char *s) +{ + if (!s) { + vkb_enc_u8(e, 0); + return; + } + uint32_t n = (uint32_t)strlen(s); + vkb_enc_u8(e, 1); + vkb_enc_u32(e, n); + vkb_enc_bytes(e, s, n); +} + +void vkb_enc_strarray(vkb_enc *e, const char *const *a, uint32_t n) +{ + if (!a) { + vkb_enc_u8(e, 0); + return; + } + vkb_enc_u8(e, 1); + vkb_enc_u32(e, n); + for (uint32_t i = 0; i < n; i++) vkb_enc_str(e, a[i]); +} + +void vkb_enc_blob(vkb_enc *e, const void *p, size_t n) +{ + if (!p) { + vkb_enc_u8(e, 0); + return; + } + vkb_enc_u8(e, 1); + vkb_enc_u64(e, n); + vkb_enc_raw(e, p, n); +} + +void vkb_enc_fd(vkb_enc *e, int fd) +{ + if (fd < 0) { + vkb_enc_u32(e, VKB_FD_NONE); + return; + } + if (e->nfds >= VKB_MAX_FDS) { + VKB_ERR("too many file descriptors in one message"); + e->oom = 1; + return; + } + e->fds[e->nfds] = fd; + vkb_enc_u32(e, (uint32_t)e->nfds); + e->nfds++; +} + +void vkb_enc_append(vkb_enc *e, const vkb_enc *src) +{ + enc_align(e); + /* fd indices inside src are relative to src; a stream that carries fds is not appendable. */ + if (src->nfds) { + VKB_ERR("internal: appending a message that carries file descriptors"); + e->oom = 1; + return; + } + vkb_enc_bytes(e, src->buf, src->len); +} + +static const VkBaseInStructure *next_known(const void *p) +{ + const VkBaseInStructure *b = p; + while (b) { + if (vkb_struct_size(b->sType)) return b; + VKB_ONCE(VKB_LOG_WARN, "pNext: structure type %d is not bridged; dropped (logged once)", (int)b->sType); + b = b->pNext; + } + return NULL; +} + +void vkb_enc_chain(vkb_enc *e, const void *pNext) +{ + const VkBaseInStructure *b = next_known(pNext); + if (!b) { + vkb_enc_u32(e, VKB_CHAIN_END); + return; + } + vkb_enc_u32(e, (uint32_t)b->sType); + vkb_enc_chain_elem(e, b); +} + +/* Out-structs that carry a caller-provided array (two-call idiom inside a struct). */ +static int out_array_info(VkStructureType t, size_t *count_off, size_t *ptr_off, size_t *elem) +{ + switch ((int)t) { + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + *count_off = offsetof(VkDrmFormatModifierPropertiesListEXT, drmFormatModifierCount); + *ptr_off = offsetof(VkDrmFormatModifierPropertiesListEXT, pDrmFormatModifierProperties); + *elem = sizeof(VkDrmFormatModifierPropertiesEXT); + return 1; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + *count_off = offsetof(VkDrmFormatModifierPropertiesList2EXT, drmFormatModifierCount); + *ptr_off = offsetof(VkDrmFormatModifierPropertiesList2EXT, pDrmFormatModifierProperties); + *elem = sizeof(VkDrmFormatModifierProperties2EXT); + return 1; + default: + return 0; + } +} + +static const VkBaseInStructure *next_known_out(const void *p) +{ + const VkBaseInStructure *b = p; + while (b) { + if (vkb_struct_size(b->sType)) return b; + VKB_ONCE(VKB_LOG_WARN, "output pNext: structure type %d is not bridged; left unfilled (logged once)", (int)b->sType); + b = b->pNext; + } + return NULL; +} + +void vkb_enc_out_template(vkb_enc *e, const void *s, size_t size) +{ + vkb_enc_raw(e, s, size); + const VkBaseInStructure *b = next_known_out(((const VkBaseInStructure *)s)->pNext); + while (b) { + size_t sz = vkb_struct_size(b->sType); + vkb_enc_u32(e, (uint32_t)b->sType); + vkb_enc_raw(e, b, sz); + size_t co, po, el; + if (out_array_info(b->sType, &co, &po, &el)) { + const void *arr; + memcpy(&arr, (const uint8_t *)b + po, sizeof(arr)); + vkb_enc_u8(e, arr != NULL); + } + b = next_known_out(b->pNext); + } + vkb_enc_u32(e, VKB_CHAIN_END); +} + +void vkb_enc_out_struct(vkb_enc *e, const void *s, size_t size) +{ + vkb_enc_raw(e, s, size); + const VkBaseInStructure *b = ((const VkBaseInStructure *)s)->pNext; + for (; b; b = b->pNext) { + size_t sz = vkb_struct_size(b->sType); + if (!sz) continue; + vkb_enc_u32(e, (uint32_t)b->sType); + vkb_enc_raw(e, b, sz); + size_t co, po, el; + if (out_array_info(b->sType, &co, &po, &el)) { + const void *arr; + uint32_t n; + memcpy(&arr, (const uint8_t *)b + po, sizeof(arr)); + memcpy(&n, (const uint8_t *)b + co, 4); + vkb_enc_u8(e, arr != NULL); + if (arr) { + vkb_enc_u32(e, n); + vkb_enc_raw(e, arr, (size_t)n * el); + } + } + } + vkb_enc_u32(e, VKB_CHAIN_END); +} + +/* ------------------------------------------------------------------ decoder */ + +void vkb_dec_init(vkb_dec *d, const void *buf, size_t len, vkb_arena *a, int *fds, int nfds) +{ + memset(d, 0, sizeof(*d)); + d->buf = buf; + d->len = len; + d->arena = a; + d->fds = fds; + d->nfds = nfds; +} + +void vkb_dec_bytes(vkb_dec *d, void *dst, size_t n) +{ + if (d->err || d->len - d->pos < n) { + d->err = 1; + if (dst) memset(dst, 0, n); + return; + } + if (dst) memcpy(dst, d->buf + d->pos, n); + d->pos += n; +} + +uint8_t vkb_dec_u8(vkb_dec *d) { uint8_t v; vkb_dec_bytes(d, &v, 1); return v; } +uint32_t vkb_dec_u32(vkb_dec *d) { uint32_t v; vkb_dec_bytes(d, &v, 4); return v; } +uint64_t vkb_dec_u64(vkb_dec *d) { uint64_t v; vkb_dec_bytes(d, &v, 8); return v; } + +static void dec_align(vkb_dec *d) +{ + size_t pad = (8 - (d->pos & 7)) & 7; + if (d->len - d->pos < pad) { + d->err = 1; + return; + } + d->pos += pad; +} + +void vkb_dec_raw_into(vkb_dec *d, void *dst, size_t n) +{ + dec_align(d); + vkb_dec_bytes(d, dst, n); +} + +const void *vkb_dec_raw_view(vkb_dec *d, size_t n) +{ + dec_align(d); + if (d->err || d->len - d->pos < n) { + d->err = 1; + return NULL; + } + const void *p = d->buf + d->pos; + d->pos += n; + return p; +} + +void *vkb_dec_alloc(vkb_dec *d, size_t n) +{ + if (d->err) return NULL; + if (n > ((size_t)1 << 32)) { + d->err = 1; + return NULL; + } + void *p = vkb_arena_alloc(d->arena, n); + if (!p) d->err = 1; + return p; +} + +void *vkb_dec_alloc_zero(vkb_dec *d, size_t n) { return vkb_dec_alloc(d, n); } + +const char *vkb_dec_str(vkb_dec *d) +{ + if (!vkb_dec_u8(d)) return NULL; + uint32_t n = vkb_dec_u32(d); + if (d->err || d->len - d->pos < n) { + d->err = 1; + return NULL; + } + char *s = vkb_dec_alloc(d, (size_t)n + 1); + if (!s) return NULL; + memcpy(s, d->buf + d->pos, n); + s[n] = 0; + d->pos += n; + return s; +} + +const char *const *vkb_dec_strarray(vkb_dec *d) +{ + if (!vkb_dec_u8(d)) return NULL; + uint32_t n = vkb_dec_u32(d); + if (d->err || n > (d->len - d->pos)) { + d->err = 1; + return NULL; + } + const char **a = vkb_dec_alloc(d, (size_t)(n ? n : 1) * sizeof(char *)); + for (uint32_t i = 0; a && i < n; i++) a[i] = vkb_dec_str(d); + return a; +} + +const void *vkb_dec_blob(vkb_dec *d, size_t *n) +{ + if (!vkb_dec_u8(d)) { + if (n) *n = 0; + return NULL; + } + uint64_t sz = vkb_dec_u64(d); + if (n) *n = (size_t)sz; + return vkb_dec_raw_view(d, (size_t)sz); +} + +void vkb_dec_blob_into(vkb_dec *d, void *dst, size_t cap) +{ + size_t n = 0; + const void *p = vkb_dec_blob(d, &n); + if (p && dst) memcpy(dst, p, n < cap ? n : cap); +} + +int vkb_dec_fd(vkb_dec *d) +{ + uint32_t i = vkb_dec_u32(d); + if (i == VKB_FD_NONE || d->err) return -1; + if ((int)i >= d->nfds || (d->fd_taken & (1u << i))) { + d->err = 1; + return -1; + } + d->fd_taken |= 1u << i; + return d->fds[i]; +} + +void vkb_dec_close_untaken(vkb_dec *d) +{ + for (int i = 0; i < d->nfds; i++) { + if (!(d->fd_taken & (1u << i)) && d->fds[i] >= 0) close(d->fds[i]); + } + d->fd_taken = 0xffffffffu; +} + +const void *vkb_dec_chain(vkb_dec *d) +{ + uint32_t t = vkb_dec_u32(d); + if (d->err || t == VKB_CHAIN_END) return NULL; + size_t sz = vkb_struct_size((VkStructureType)t); + if (!sz) { + VKB_ERR("protocol: unknown structure type %u in a chain", t); + d->err = 1; + return NULL; + } + void *p = vkb_dec_alloc(d, sz); + if (!p) return NULL; + vkb_dec_chain_elem(d, (VkStructureType)t, p); + return p; +} + +void vkb_dec_out_template(vkb_dec *d, void *dst, size_t size) +{ + vkb_dec_raw_into(d, dst, size); + VkBaseOutStructure *prev = dst; + prev->pNext = NULL; + for (;;) { + uint32_t t = vkb_dec_u32(d); + if (d->err || t == VKB_CHAIN_END) break; + size_t sz = vkb_struct_size((VkStructureType)t); + if (!sz) { + d->err = 1; + break; + } + VkBaseOutStructure *el = vkb_dec_alloc(d, sz); + if (!el) break; + vkb_dec_raw_into(d, el, sz); + el->pNext = NULL; + size_t co, po, es; + if (out_array_info((VkStructureType)t, &co, &po, &es)) { + void *arr = NULL; + if (vkb_dec_u8(d)) { + uint32_t n; + memcpy(&n, (uint8_t *)el + co, 4); + arr = vkb_dec_alloc(d, (size_t)(n ? n : 1) * es); + } + memcpy((uint8_t *)el + po, &arr, sizeof(arr)); + } + prev->pNext = el; + prev = el; + } +} + +void vkb_dec_out_struct(vkb_dec *d, void *dst, size_t size) +{ + VkBaseOutStructure *top = dst; + VkBaseOutStructure *keep = top->pNext; + vkb_dec_raw_into(d, dst, size); + top->pNext = keep; + VkBaseOutStructure *app = (VkBaseOutStructure *)next_known_out(keep); + for (;;) { + uint32_t t = vkb_dec_u32(d); + if (d->err || t == VKB_CHAIN_END) break; + size_t sz = vkb_struct_size((VkStructureType)t); + const uint8_t *src = vkb_dec_raw_view(d, sz); + if (!src || !sz) { + d->err = 1; + break; + } + size_t co, po, es; + int has_arr = out_array_info((VkStructureType)t, &co, &po, &es); + uint8_t arr_present = has_arr ? vkb_dec_u8(d) : 0; + uint32_t arr_n = 0; + const uint8_t *arr_src = NULL; + if (arr_present) { + arr_n = vkb_dec_u32(d); + arr_src = vkb_dec_raw_view(d, (size_t)arr_n * es); + } + if (!app || (uint32_t)app->sType != t) { + /* The server answered for a structure we did not send: protocol mismatch. */ + d->err = 1; + break; + } + VkBaseOutStructure *keep_next = app->pNext; + uint32_t cap = 0; + void *app_arr = NULL; + if (has_arr) { + memcpy(&cap, (uint8_t *)app + co, 4); + memcpy(&app_arr, (uint8_t *)app + po, sizeof(app_arr)); + } + memcpy(app, src, sz); + app->pNext = keep_next; + if (has_arr) { + memcpy((uint8_t *)app + po, &app_arr, sizeof(app_arr)); + if (app_arr && arr_src) { + uint32_t n = arr_n < cap ? arr_n : cap; + memcpy(app_arr, arr_src, (size_t)n * es); + memcpy((uint8_t *)app + co, &n, 4); + } + } + app = (VkBaseOutStructure *)next_known_out(keep_next); + } +} + +void vkb_close_fd(int fd) +{ + if (fd >= 0) close(fd); +} + +/* ------------------------------------------------------------------ predicates */ + +int vkb_desc_has_image(VkDescriptorType t) +{ + return t == VK_DESCRIPTOR_TYPE_SAMPLER || t == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER || + t == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || t == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE || + t == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT || t == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM || + t == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM; +} + +int vkb_desc_has_buffer(VkDescriptorType t) +{ + return t == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || t == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || + t == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || t == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; +} + +int vkb_desc_has_texel(VkDescriptorType t) +{ + return t == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER || t == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; +} + +int vkb_gp_has_tess(const VkGraphicsPipelineCreateInfo *s) +{ + if (!s->pStages) return 1; /* library pieces: trust the pointer */ + for (uint32_t i = 0; i < s->stageCount; i++) { + if (s->pStages[i].stage & (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)) + return 1; + } + return 0; +} + +/* ------------------------------------------------------------------ transport */ + +int vkb_send_msg(int sock, const vkb_msg_hdr *h, const void *payload, const int *fds, int nfds) +{ + struct iovec iov[2]; + iov[0].iov_base = (void *)h; + iov[0].iov_len = sizeof(*h); + iov[1].iov_base = (void *)payload; + iov[1].iov_len = h->size; + union { + char buf[CMSG_SPACE(sizeof(int) * VKB_MAX_FDS)]; + struct cmsghdr align; + } cm; + struct msghdr msg; + memset(&msg, 0, sizeof(msg)); + msg.msg_iov = iov; + msg.msg_iovlen = h->size ? 2 : 1; + if (nfds > 0) { + memset(&cm, 0, sizeof(cm)); + msg.msg_control = cm.buf; + msg.msg_controllen = CMSG_SPACE(sizeof(int) * nfds); + struct cmsghdr *c = CMSG_FIRSTHDR(&msg); + c->cmsg_level = SOL_SOCKET; + c->cmsg_type = SCM_RIGHTS; + c->cmsg_len = CMSG_LEN(sizeof(int) * nfds); + memcpy(CMSG_DATA(c), fds, sizeof(int) * nfds); + } + size_t total = sizeof(*h) + h->size; + size_t sent = 0; + while (sent < total) { + ssize_t r = sendmsg(sock, &msg, MSG_NOSIGNAL); + if (r < 0) { + if (errno == EINTR) continue; + return -1; + } + sent += (size_t)r; + if (sent >= total) break; + /* Partial write: advance the iovecs; fds went with the first chunk. */ + msg.msg_control = NULL; + msg.msg_controllen = 0; + size_t skip = (size_t)r; + while (msg.msg_iovlen && skip >= msg.msg_iov[0].iov_len) { + skip -= msg.msg_iov[0].iov_len; + msg.msg_iov++; + msg.msg_iovlen--; + } + if (msg.msg_iovlen) { + msg.msg_iov[0].iov_base = (uint8_t *)msg.msg_iov[0].iov_base + skip; + msg.msg_iov[0].iov_len -= skip; + } + } + return 0; +} + +static int read_full(int sock, void *buf, size_t n) +{ + size_t got = 0; + while (got < n) { + ssize_t r = recv(sock, (uint8_t *)buf + got, n - got, 0); + if (r == 0) return -1; + if (r < 0) { + if (errno == EINTR) continue; + return -1; + } + got += (size_t)r; + } + return 0; +} + +int vkb_recv_msg(int sock, vkb_msg_hdr *h, uint8_t **payload, size_t *cap, int *fds, int *nfds) +{ + union { + char buf[CMSG_SPACE(sizeof(int) * VKB_MAX_FDS)]; + struct cmsghdr align; + } cm; + struct iovec iov = {h, sizeof(*h)}; + struct msghdr msg; + memset(&msg, 0, sizeof(msg)); + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + msg.msg_control = cm.buf; + msg.msg_controllen = sizeof(cm.buf); + *nfds = 0; + ssize_t r; + do { + r = recvmsg(sock, &msg, MSG_CMSG_CLOEXEC); + } while (r < 0 && errno == EINTR); + if (r <= 0) return -1; + for (struct cmsghdr *c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) { + if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_RIGHTS) { + int n = (int)((c->cmsg_len - CMSG_LEN(0)) / sizeof(int)); + for (int i = 0; i < n; i++) { + int fd; + memcpy(&fd, CMSG_DATA(c) + i * sizeof(int), sizeof(int)); + if (*nfds < VKB_MAX_FDS) fds[(*nfds)++] = fd; + else close(fd); + } + } + } + if ((size_t)r < sizeof(*h) && read_full(sock, (uint8_t *)h + r, sizeof(*h) - (size_t)r) < 0) goto fail; + if (h->magic != VKB_MAGIC) { + VKB_ERR("transport: bad message magic 0x%08x", h->magic); + goto fail; + } + if (h->size) { + if (h->size > *cap) { + size_t nc = *cap ? *cap : 65536; + while (nc < h->size) nc *= 2; + uint8_t *nb = realloc(*payload, nc); + if (!nb) goto fail; + *payload = nb; + *cap = nc; + } + if (read_full(sock, *payload, h->size) < 0) goto fail; + } + return 0; +fail: + for (int i = 0; i < *nfds; i++) close(fds[i]); + *nfds = 0; + return -1; +} diff --git a/tools/vkbridge/common/vkb_wire.h b/tools/vkbridge/common/vkb_wire.h new file mode 100644 index 000000000..6930123be --- /dev/null +++ b/tools/vkbridge/common/vkb_wire.h @@ -0,0 +1,118 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Wire primitives shared by the bridge's client ICD (glibc) and server (bionic). + * See tools/vkbridge/README.md for the protocol. + */ +#ifndef VKB_WIRE_H +#define VKB_WIRE_H + +#include +#include +#include "gen/vkb_gen.h" + +#define VKB_MAX_FDS 16 +#define VKB_CHAIN_END 0x7FFFFFFFu +#define VKB_FD_NONE 0xFFFFFFFFu + +/* ---- arena: per-call scratch memory on the decoding side ---- */ +typedef struct vkb_arena_block vkb_arena_block; +typedef struct vkb_arena { + vkb_arena_block *head; + size_t used_total; +} vkb_arena; +void *vkb_arena_alloc(vkb_arena *a, size_t n); +void vkb_arena_reset(vkb_arena *a); +void vkb_arena_free(vkb_arena *a); + +/* ---- encoder ---- */ +struct vkb_enc { + uint8_t *buf; + size_t len, cap; + int fds[VKB_MAX_FDS]; + int nfds; + int oom; +}; +void vkb_enc_init(vkb_enc *e); +void vkb_enc_reset(vkb_enc *e); /* keeps the buffer */ +void vkb_enc_free(vkb_enc *e); +void vkb_enc_bytes(vkb_enc *e, const void *p, size_t n); +void vkb_enc_u8(vkb_enc *e, uint8_t v); +void vkb_enc_u32(vkb_enc *e, uint32_t v); +void vkb_enc_u64(vkb_enc *e, uint64_t v); +size_t vkb_enc_raw(vkb_enc *e, const void *p, size_t n); /* 8-aligned; returns offset */ +void vkb_enc_patch_u64(vkb_enc *e, size_t off, uint64_t v); +void vkb_enc_str(vkb_enc *e, const char *s); +void vkb_enc_strarray(vkb_enc *e, const char *const *a, uint32_t n); +void vkb_enc_blob(vkb_enc *e, const void *p, size_t n); +void vkb_enc_fd(vkb_enc *e, int fd); /* sent with the message */ +void vkb_enc_chain(vkb_enc *e, const void *pNext); +void vkb_enc_out_template(vkb_enc *e, const void *s, size_t size); /* client */ +void vkb_enc_out_struct(vkb_enc *e, const void *s, size_t size); /* server */ +void vkb_enc_append(vkb_enc *e, const vkb_enc *src); /* bytes + fds */ + +/* ---- decoder ---- */ +struct vkb_dec { + const uint8_t *buf; + size_t pos, len; + int err; + vkb_arena *arena; + int *fds; + int nfds; + uint32_t fd_taken; /* bitmask of fds handed out */ +}; +void vkb_dec_init(vkb_dec *d, const void *buf, size_t len, vkb_arena *a, int *fds, int nfds); +void vkb_dec_bytes(vkb_dec *d, void *dst, size_t n); +uint8_t vkb_dec_u8(vkb_dec *d); +uint32_t vkb_dec_u32(vkb_dec *d); +uint64_t vkb_dec_u64(vkb_dec *d); +void vkb_dec_raw_into(vkb_dec *d, void *dst, size_t n); +const void *vkb_dec_raw_view(vkb_dec *d, size_t n); +void *vkb_dec_alloc(vkb_dec *d, size_t n); /* zeroed */ +void *vkb_dec_alloc_zero(vkb_dec *d, size_t n); +const char *vkb_dec_str(vkb_dec *d); +const char *const *vkb_dec_strarray(vkb_dec *d); +const void *vkb_dec_blob(vkb_dec *d, size_t *n); +void vkb_dec_blob_into(vkb_dec *d, void *dst, size_t cap); +int vkb_dec_fd(vkb_dec *d); /* caller owns the fd */ +const void *vkb_dec_chain(vkb_dec *d); +void vkb_dec_out_template(vkb_dec *d, void *dst, size_t size); /* server */ +void vkb_dec_out_struct(vkb_dec *d, void *dst, size_t size); /* client */ +void vkb_dec_close_untaken(vkb_dec *d); + +void vkb_close_fd(int fd); + +/* Descriptor-type predicates used by generated encoders. */ +int vkb_desc_has_image(VkDescriptorType t); +int vkb_desc_has_buffer(VkDescriptorType t); +int vkb_desc_has_texel(VkDescriptorType t); +int vkb_gp_has_tess(const VkGraphicsPipelineCreateInfo *s); +/* Defined per side: on the client it consults the command buffer's level. */ +int vkb_cb_begin_is_secondary(const VkCommandBufferBeginInfo *s); + +/* Defined per side: client maps a dispatchable handle to the server's value; server: identity. */ +uint64_t vkb_remote(const void *dispatchable); + +/* ---- transport ---- */ +typedef struct vkb_msg_hdr { + uint32_t magic; /* VKB_MAGIC */ + uint32_t size; /* payload bytes after the header */ + uint32_t cmd; /* request: command id; reply: status (0 = ok) */ + uint32_t table; /* request: server dispatch table id */ + uint32_t nfds; + uint32_t flags; +} vkb_msg_hdr; +#define VKB_MAGIC 0x31424b56u /* "VKB1" */ +#define VKB_F_NOREPLY 1u + +/* Reply status codes (vkb_msg_hdr.cmd in replies). */ +#define VKB_ST_OK 0u +#define VKB_ST_BAD_MESSAGE 1u +#define VKB_ST_MISSING 2u +#define VKB_ST_BAD_TABLE 3u + +int vkb_send_msg(int sock, const vkb_msg_hdr *h, const void *payload, const int *fds, int nfds); +/* Receives one message; *payload is malloc'd (or reused when *cap suffices). Returns 0 on + * success, -1 on EOF/error. fds[] receives up to VKB_MAX_FDS descriptors. */ +int vkb_recv_msg(int sock, vkb_msg_hdr *h, uint8_t **payload, size_t *cap, int *fds, int *nfds); + +#endif diff --git a/tools/vkbridge/host/.gitignore b/tools/vkbridge/host/.gitignore new file mode 100644 index 000000000..89f9ac04a --- /dev/null +++ b/tools/vkbridge/host/.gitignore @@ -0,0 +1 @@ +out/ diff --git a/tools/vkbridge/host/Makefile b/tools/vkbridge/host/Makefile new file mode 100644 index 000000000..88aee2803 --- /dev/null +++ b/tools/vkbridge/host/Makefile @@ -0,0 +1,39 @@ +# Host (x86_64 Linux) build of both bridge halves, for testing against the desktop's own Vulkan +# driver: the server loads libvulkan.so.1 (pick a driver with VK_DRIVER_FILES in ITS environment), +# the client ICD is what test programs load (VK_DRIVER_FILES=$(OUT)/vkbridge_icd.json). +# make -C tools/vkbridge/host build +# make -C tools/vkbridge/host test vulkaninfo + vkcube-headless smoke tests +ROOT := $(abspath ../../..) +VKB := $(ROOT)/tools/vkbridge +SRV := $(ROOT)/app/src/main/cpp/vkbridge +OUT ?= $(VKB)/host/out +CC ?= gcc +CFLAGS ?= -O1 -g +WARN := -Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers -Wno-sign-compare +INC := -I$(VKB)/third_party/Vulkan-Headers-1.3.247/include -I$(VKB)/common -I$(VKB)/common/gen +COMMON_SRC := $(VKB)/common/vkb_wire.c $(VKB)/common/gen/vkb_gen_structs.c +SERVER_SRC := $(wildcard $(SRV)/*.c) $(VKB)/common/gen/vkb_gen_server.c $(COMMON_SRC) +CLIENT_SRC := $(wildcard $(VKB)/client/*.c) $(VKB)/common/gen/vkb_gen_client.c $(COMMON_SRC) + +all: $(OUT)/vkbridge-server $(OUT)/libvulkan_droidbridge.so $(OUT)/vkbridge_icd.json + +$(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 + +$(OUT)/libvulkan_droidbridge.so: $(CLIENT_SRC) $(wildcard $(VKB)/client/*.h $(VKB)/common/*.h $(VKB)/common/gen/*.h) + @mkdir -p $(OUT) + $(CC) $(CFLAGS) $(WARN) -fPIC -shared -fvisibility=hidden -DVKB_CLIENT $(INC) -I$(VKB)/client -I$(VKB)/client/compat \ + -o $@ $(CLIENT_SRC) -ldl -lpthread -Wl,--no-undefined + +$(OUT)/vkbridge_icd.json: + @mkdir -p $(OUT) + printf '{"file_format_version":"1.0.0","ICD":{"library_path":"%s","api_version":"1.3.247"}}\n' "$(OUT)/libvulkan_droidbridge.so" > $@ + +test: all + $(VKB)/host/run_tests.sh $(OUT) + +clean: + rm -rf $(OUT) + +.PHONY: all test clean diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/LICENSE.txt b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/LICENSE.txt new file mode 100644 index 000000000..d64569567 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/LICENSE.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std.h new file mode 100644 index 000000000..21c7b667f --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std.h @@ -0,0 +1,310 @@ +#ifndef VULKAN_VIDEO_CODEC_H264STD_H_ +#define VULKAN_VIDEO_CODEC_H264STD_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define vulkan_video_codec_h264std 1 +#include +#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32 +#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6 +#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16 +#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6 +#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64 +#define STD_VIDEO_H264_MAX_NUM_LIST_REF 32 +#define STD_VIDEO_H264_MAX_CHROMA_PLANES 2 + +typedef enum StdVideoH264ChromaFormatIdc { + STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_420 = 1, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_422 = 2, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_444 = 3, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ChromaFormatIdc; + +typedef enum StdVideoH264ProfileIdc { + STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66, + STD_VIDEO_H264_PROFILE_IDC_MAIN = 77, + STD_VIDEO_H264_PROFILE_IDC_HIGH = 100, + STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244, + STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ProfileIdc; + +typedef enum StdVideoH264LevelIdc { + STD_VIDEO_H264_LEVEL_IDC_1_0 = 0, + STD_VIDEO_H264_LEVEL_IDC_1_1 = 1, + STD_VIDEO_H264_LEVEL_IDC_1_2 = 2, + STD_VIDEO_H264_LEVEL_IDC_1_3 = 3, + STD_VIDEO_H264_LEVEL_IDC_2_0 = 4, + STD_VIDEO_H264_LEVEL_IDC_2_1 = 5, + STD_VIDEO_H264_LEVEL_IDC_2_2 = 6, + STD_VIDEO_H264_LEVEL_IDC_3_0 = 7, + STD_VIDEO_H264_LEVEL_IDC_3_1 = 8, + STD_VIDEO_H264_LEVEL_IDC_3_2 = 9, + STD_VIDEO_H264_LEVEL_IDC_4_0 = 10, + STD_VIDEO_H264_LEVEL_IDC_4_1 = 11, + STD_VIDEO_H264_LEVEL_IDC_4_2 = 12, + STD_VIDEO_H264_LEVEL_IDC_5_0 = 13, + STD_VIDEO_H264_LEVEL_IDC_5_1 = 14, + STD_VIDEO_H264_LEVEL_IDC_5_2 = 15, + STD_VIDEO_H264_LEVEL_IDC_6_0 = 16, + STD_VIDEO_H264_LEVEL_IDC_6_1 = 17, + STD_VIDEO_H264_LEVEL_IDC_6_2 = 18, + STD_VIDEO_H264_LEVEL_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264LevelIdc; + +typedef enum StdVideoH264PocType { + STD_VIDEO_H264_POC_TYPE_0 = 0, + STD_VIDEO_H264_POC_TYPE_1 = 1, + STD_VIDEO_H264_POC_TYPE_2 = 2, + STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_POC_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264PocType; + +typedef enum StdVideoH264AspectRatioIdc { + STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED = 0, + STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE = 1, + STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11 = 2, + STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11 = 3, + STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11 = 4, + STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33 = 5, + STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11 = 6, + STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11 = 7, + STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11 = 8, + STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33 = 9, + STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11 = 10, + STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11 = 11, + STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33 = 12, + STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99 = 13, + STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3 = 14, + STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2 = 15, + STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1 = 16, + STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, + STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264AspectRatioIdc; + +typedef enum StdVideoH264WeightedBipredIdc { + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT = 0, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT = 1, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT = 2, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264WeightedBipredIdc; + +typedef enum StdVideoH264ModificationOfPicNumsIdc { + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT = 0, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD = 1, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM = 2, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END = 3, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ModificationOfPicNumsIdc; + +typedef enum StdVideoH264MemMgmtControlOp { + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END = 0, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM = 1, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM = 2, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM = 3, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX = 4, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL = 5, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM = 6, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264MemMgmtControlOp; + +typedef enum StdVideoH264CabacInitIdc { + STD_VIDEO_H264_CABAC_INIT_IDC_0 = 0, + STD_VIDEO_H264_CABAC_INIT_IDC_1 = 1, + STD_VIDEO_H264_CABAC_INIT_IDC_2 = 2, + STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_CABAC_INIT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264CabacInitIdc; + +typedef enum StdVideoH264DisableDeblockingFilterIdc { + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED = 0, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED = 1, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL = 2, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264DisableDeblockingFilterIdc; + +typedef enum StdVideoH264SliceType { + STD_VIDEO_H264_SLICE_TYPE_P = 0, + STD_VIDEO_H264_SLICE_TYPE_B = 1, + STD_VIDEO_H264_SLICE_TYPE_I = 2, + STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264SliceType; + +typedef enum StdVideoH264PictureType { + STD_VIDEO_H264_PICTURE_TYPE_P = 0, + STD_VIDEO_H264_PICTURE_TYPE_B = 1, + STD_VIDEO_H264_PICTURE_TYPE_I = 2, + STD_VIDEO_H264_PICTURE_TYPE_IDR = 5, + STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264PictureType; + +typedef enum StdVideoH264NonVclNaluType { + STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS = 0, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS = 1, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD = 2, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX = 3, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE = 4, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM = 5, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED = 6, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264NonVclNaluType; +typedef struct StdVideoH264SpsVuiFlags { + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t color_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t timing_info_present_flag : 1; + uint32_t fixed_frame_rate_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; +} StdVideoH264SpsVuiFlags; + +typedef struct StdVideoH264HrdParameters { + uint8_t cpb_cnt_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint8_t reserved1; + uint32_t bit_rate_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint8_t cbr_flag[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint32_t initial_cpb_removal_delay_length_minus1; + uint32_t cpb_removal_delay_length_minus1; + uint32_t dpb_output_delay_length_minus1; + uint32_t time_offset_length; +} StdVideoH264HrdParameters; + +typedef struct StdVideoH264SequenceParameterSetVui { + StdVideoH264SpsVuiFlags flags; + StdVideoH264AspectRatioIdc aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coefficients; + uint32_t num_units_in_tick; + uint32_t time_scale; + uint8_t max_num_reorder_frames; + uint8_t max_dec_frame_buffering; + uint8_t chroma_sample_loc_type_top_field; + uint8_t chroma_sample_loc_type_bottom_field; + uint32_t reserved1; + const StdVideoH264HrdParameters* pHrdParameters; +} StdVideoH264SequenceParameterSetVui; + +typedef struct StdVideoH264SpsFlags { + uint32_t constraint_set0_flag : 1; + uint32_t constraint_set1_flag : 1; + uint32_t constraint_set2_flag : 1; + uint32_t constraint_set3_flag : 1; + uint32_t constraint_set4_flag : 1; + uint32_t constraint_set5_flag : 1; + uint32_t direct_8x8_inference_flag : 1; + uint32_t mb_adaptive_frame_field_flag : 1; + uint32_t frame_mbs_only_flag : 1; + uint32_t delta_pic_order_always_zero_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t gaps_in_frame_num_value_allowed_flag : 1; + uint32_t qpprime_y_zero_transform_bypass_flag : 1; + uint32_t frame_cropping_flag : 1; + uint32_t seq_scaling_matrix_present_flag : 1; + uint32_t vui_parameters_present_flag : 1; +} StdVideoH264SpsFlags; + +typedef struct StdVideoH264ScalingLists { + uint16_t scaling_list_present_mask; + uint16_t use_default_scaling_matrix_mask; + uint8_t ScalingList4x4[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS]; + uint8_t ScalingList8x8[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS]; +} StdVideoH264ScalingLists; + +typedef struct StdVideoH264SequenceParameterSet { + StdVideoH264SpsFlags flags; + StdVideoH264ProfileIdc profile_idc; + StdVideoH264LevelIdc level_idc; + StdVideoH264ChromaFormatIdc chroma_format_idc; + uint8_t seq_parameter_set_id; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_frame_num_minus4; + StdVideoH264PocType pic_order_cnt_type; + int32_t offset_for_non_ref_pic; + int32_t offset_for_top_to_bottom_field; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + uint8_t num_ref_frames_in_pic_order_cnt_cycle; + uint8_t max_num_ref_frames; + uint8_t reserved1; + uint32_t pic_width_in_mbs_minus1; + uint32_t pic_height_in_map_units_minus1; + uint32_t frame_crop_left_offset; + uint32_t frame_crop_right_offset; + uint32_t frame_crop_top_offset; + uint32_t frame_crop_bottom_offset; + uint32_t reserved2; + const int32_t* pOffsetForRefFrame; + const StdVideoH264ScalingLists* pScalingLists; + const StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; +} StdVideoH264SequenceParameterSet; + +typedef struct StdVideoH264PpsFlags { + uint32_t transform_8x8_mode_flag : 1; + uint32_t redundant_pic_cnt_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t bottom_field_pic_order_in_frame_present_flag : 1; + uint32_t entropy_coding_mode_flag : 1; + uint32_t pic_scaling_matrix_present_flag : 1; +} StdVideoH264PpsFlags; + +typedef struct StdVideoH264PictureParameterSet { + StdVideoH264PpsFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + StdVideoH264WeightedBipredIdc weighted_bipred_idc; + int8_t pic_init_qp_minus26; + int8_t pic_init_qs_minus26; + int8_t chroma_qp_index_offset; + int8_t second_chroma_qp_index_offset; + const StdVideoH264ScalingLists* pScalingLists; +} StdVideoH264PictureParameterSet; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std_decode.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std_decode.h new file mode 100644 index 000000000..f7eb8edbd --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std_decode.h @@ -0,0 +1,75 @@ +#ifndef VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define vulkan_video_codec_h264std_decode 1 + +#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_decode" + +typedef enum StdVideoDecodeH264FieldOrderCount { + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM = 1, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID = 0x7FFFFFFF, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_MAX_ENUM = 0x7FFFFFFF +} StdVideoDecodeH264FieldOrderCount; +typedef struct StdVideoDecodeH264PictureInfoFlags { + uint32_t field_pic_flag : 1; + uint32_t is_intra : 1; + uint32_t IdrPicFlag : 1; + uint32_t bottom_field_flag : 1; + uint32_t is_reference : 1; + uint32_t complementary_field_pair : 1; +} StdVideoDecodeH264PictureInfoFlags; + +typedef struct StdVideoDecodeH264PictureInfo { + StdVideoDecodeH264PictureInfoFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint8_t reserved1; + uint8_t reserved2; + uint16_t frame_num; + uint16_t idr_pic_id; + int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; +} StdVideoDecodeH264PictureInfo; + +typedef struct StdVideoDecodeH264ReferenceInfoFlags { + uint32_t top_field_flag : 1; + uint32_t bottom_field_flag : 1; + uint32_t used_for_long_term_reference : 1; + uint32_t is_non_existing : 1; +} StdVideoDecodeH264ReferenceInfoFlags; + +typedef struct StdVideoDecodeH264ReferenceInfo { + StdVideoDecodeH264ReferenceInfoFlags flags; + uint16_t FrameNum; + uint16_t reserved; + int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; +} StdVideoDecodeH264ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std_encode.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std_encode.h new file mode 100644 index 000000000..d4edb40ee --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h264std_encode.h @@ -0,0 +1,141 @@ +#ifndef VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ +#define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define vulkan_video_codec_h264std_encode 1 +// Vulkan 0.9 provisional Vulkan video H.264 encode std specification version number +#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_9 VK_MAKE_VIDEO_STD_VERSION(0, 9, 9) + +#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_0_9_9 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_encode" +typedef struct StdVideoEncodeH264WeightTableFlags { + uint32_t luma_weight_l0_flag; + uint32_t chroma_weight_l0_flag; + uint32_t luma_weight_l1_flag; + uint32_t chroma_weight_l1_flag; +} StdVideoEncodeH264WeightTableFlags; + +typedef struct StdVideoEncodeH264WeightTable { + StdVideoEncodeH264WeightTableFlags flags; + uint8_t luma_log2_weight_denom; + uint8_t chroma_log2_weight_denom; + int8_t luma_weight_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + int8_t luma_offset_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + int8_t chroma_weight_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; + int8_t chroma_offset_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; + int8_t luma_weight_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + int8_t luma_offset_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + int8_t chroma_weight_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; + int8_t chroma_offset_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; +} StdVideoEncodeH264WeightTable; + +typedef struct StdVideoEncodeH264SliceHeaderFlags { + uint32_t direct_spatial_mv_pred_flag : 1; + uint32_t num_ref_idx_active_override_flag : 1; + uint32_t no_output_of_prior_pics_flag : 1; + uint32_t adaptive_ref_pic_marking_mode_flag : 1; + uint32_t no_prior_references_available_flag : 1; +} StdVideoEncodeH264SliceHeaderFlags; + +typedef struct StdVideoEncodeH264PictureInfoFlags { + uint32_t idr_flag : 1; + uint32_t is_reference_flag : 1; + uint32_t used_for_long_term_reference : 1; +} StdVideoEncodeH264PictureInfoFlags; + +typedef struct StdVideoEncodeH264ReferenceInfoFlags { + uint32_t used_for_long_term_reference : 1; +} StdVideoEncodeH264ReferenceInfoFlags; + +typedef struct StdVideoEncodeH264ReferenceListsInfoFlags { + uint32_t ref_pic_list_modification_flag_l0 : 1; + uint32_t ref_pic_list_modification_flag_l1 : 1; +} StdVideoEncodeH264ReferenceListsInfoFlags; + +typedef struct StdVideoEncodeH264RefListModEntry { + StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc; + uint16_t abs_diff_pic_num_minus1; + uint16_t long_term_pic_num; +} StdVideoEncodeH264RefListModEntry; + +typedef struct StdVideoEncodeH264RefPicMarkingEntry { + StdVideoH264MemMgmtControlOp operation; + uint16_t difference_of_pic_nums_minus1; + uint16_t long_term_pic_num; + uint16_t long_term_frame_idx; + uint16_t max_long_term_frame_idx_plus1; +} StdVideoEncodeH264RefPicMarkingEntry; + +typedef struct StdVideoEncodeH264ReferenceListsInfo { + StdVideoEncodeH264ReferenceListsInfoFlags flags; + uint8_t refPicList0EntryCount; + uint8_t refPicList1EntryCount; + uint8_t refList0ModOpCount; + uint8_t refList1ModOpCount; + uint8_t refPicMarkingOpCount; + uint8_t reserved1[7]; + const uint8_t* pRefPicList0Entries; + const uint8_t* pRefPicList1Entries; + const StdVideoEncodeH264RefListModEntry* pRefList0ModOperations; + const StdVideoEncodeH264RefListModEntry* pRefList1ModOperations; + const StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations; +} StdVideoEncodeH264ReferenceListsInfo; + +typedef struct StdVideoEncodeH264PictureInfo { + StdVideoEncodeH264PictureInfoFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint16_t reserved1; + StdVideoH264PictureType pictureType; + uint32_t frame_num; + int32_t PicOrderCnt; +} StdVideoEncodeH264PictureInfo; + +typedef struct StdVideoEncodeH264ReferenceInfo { + StdVideoEncodeH264ReferenceInfoFlags flags; + StdVideoH264PictureType pictureType; + uint32_t FrameNum; + int32_t PicOrderCnt; + uint16_t long_term_pic_num; + uint16_t long_term_frame_idx; +} StdVideoEncodeH264ReferenceInfo; + +typedef struct StdVideoEncodeH264SliceHeader { + StdVideoEncodeH264SliceHeaderFlags flags; + uint32_t first_mb_in_slice; + StdVideoH264SliceType slice_type; + uint16_t idr_pic_id; + uint8_t num_ref_idx_l0_active_minus1; + uint8_t num_ref_idx_l1_active_minus1; + StdVideoH264CabacInitIdc cabac_init_idc; + StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; + int8_t slice_alpha_c0_offset_div2; + int8_t slice_beta_offset_div2; + uint16_t reserved1; + uint32_t reserved2; + const StdVideoEncodeH264WeightTable* pWeightTable; +} StdVideoEncodeH264SliceHeader; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std.h new file mode 100644 index 000000000..4233bdc89 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std.h @@ -0,0 +1,443 @@ +#ifndef VULKAN_VIDEO_CODEC_H265STD_H_ +#define VULKAN_VIDEO_CODEC_H265STD_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define vulkan_video_codec_h265std 1 +#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7 +#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32 +#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6 +#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16 +#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6 +#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64 +#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6 +#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64 +#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2 +#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64 +#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3 +#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128 +#define STD_VIDEO_H265_MAX_DPB_SIZE 16 +#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32 +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6 +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19 +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21 +#define STD_VIDEO_H265_MAX_NUM_LIST_REF 15 +#define STD_VIDEO_H265_MAX_CHROMA_PLANES 2 +#define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64 +#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16 +#define STD_VIDEO_H265_MAX_DELTA_POC 48 + +typedef enum StdVideoH265ChromaFormatIdc { + STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_420 = 1, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_422 = 2, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_444 = 3, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265ChromaFormatIdc; + +typedef enum StdVideoH265ProfileIdc { + STD_VIDEO_H265_PROFILE_IDC_MAIN = 1, + STD_VIDEO_H265_PROFILE_IDC_MAIN_10 = 2, + STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE = 3, + STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS = 4, + STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS = 9, + STD_VIDEO_H265_PROFILE_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265ProfileIdc; + +typedef enum StdVideoH265LevelIdc { + STD_VIDEO_H265_LEVEL_IDC_1_0 = 0, + STD_VIDEO_H265_LEVEL_IDC_2_0 = 1, + STD_VIDEO_H265_LEVEL_IDC_2_1 = 2, + STD_VIDEO_H265_LEVEL_IDC_3_0 = 3, + STD_VIDEO_H265_LEVEL_IDC_3_1 = 4, + STD_VIDEO_H265_LEVEL_IDC_4_0 = 5, + STD_VIDEO_H265_LEVEL_IDC_4_1 = 6, + STD_VIDEO_H265_LEVEL_IDC_5_0 = 7, + STD_VIDEO_H265_LEVEL_IDC_5_1 = 8, + STD_VIDEO_H265_LEVEL_IDC_5_2 = 9, + STD_VIDEO_H265_LEVEL_IDC_6_0 = 10, + STD_VIDEO_H265_LEVEL_IDC_6_1 = 11, + STD_VIDEO_H265_LEVEL_IDC_6_2 = 12, + STD_VIDEO_H265_LEVEL_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265LevelIdc; + +typedef enum StdVideoH265SliceType { + STD_VIDEO_H265_SLICE_TYPE_B = 0, + STD_VIDEO_H265_SLICE_TYPE_P = 1, + STD_VIDEO_H265_SLICE_TYPE_I = 2, + STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265SliceType; + +typedef enum StdVideoH265PictureType { + STD_VIDEO_H265_PICTURE_TYPE_P = 0, + STD_VIDEO_H265_PICTURE_TYPE_B = 1, + STD_VIDEO_H265_PICTURE_TYPE_I = 2, + STD_VIDEO_H265_PICTURE_TYPE_IDR = 3, + STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265PictureType; + +typedef enum StdVideoH265AspectRatioIdc { + STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED = 0, + STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE = 1, + STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11 = 2, + STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11 = 3, + STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11 = 4, + STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33 = 5, + STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11 = 6, + STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11 = 7, + STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11 = 8, + STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33 = 9, + STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11 = 10, + STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11 = 11, + STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33 = 12, + STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99 = 13, + STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3 = 14, + STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2 = 15, + STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1 = 16, + STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, + STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265AspectRatioIdc; +typedef struct StdVideoH265DecPicBufMgr { + uint32_t max_latency_increase_plus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint8_t max_dec_pic_buffering_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint8_t max_num_reorder_pics[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; +} StdVideoH265DecPicBufMgr; + +typedef struct StdVideoH265SubLayerHrdParameters { + uint32_t bit_rate_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t bit_rate_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cbr_flag; +} StdVideoH265SubLayerHrdParameters; + +typedef struct StdVideoH265HrdFlags { + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; + uint32_t sub_pic_hrd_params_present_flag : 1; + uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; + uint32_t fixed_pic_rate_general_flag : 8; + uint32_t fixed_pic_rate_within_cvs_flag : 8; + uint32_t low_delay_hrd_flag : 8; +} StdVideoH265HrdFlags; + +typedef struct StdVideoH265HrdParameters { + StdVideoH265HrdFlags flags; + uint8_t tick_divisor_minus2; + uint8_t du_cpb_removal_delay_increment_length_minus1; + uint8_t dpb_output_delay_du_length_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint8_t cpb_size_du_scale; + uint8_t initial_cpb_removal_delay_length_minus1; + uint8_t au_cpb_removal_delay_length_minus1; + uint8_t dpb_output_delay_length_minus1; + uint8_t cpb_cnt_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint16_t elemental_duration_in_tc_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint16_t reserved[3]; + const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal; + const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl; +} StdVideoH265HrdParameters; + +typedef struct StdVideoH265VpsFlags { + uint32_t vps_temporal_id_nesting_flag : 1; + uint32_t vps_sub_layer_ordering_info_present_flag : 1; + uint32_t vps_timing_info_present_flag : 1; + uint32_t vps_poc_proportional_to_timing_flag : 1; +} StdVideoH265VpsFlags; + +typedef struct StdVideoH265ProfileTierLevelFlags { + uint32_t general_tier_flag : 1; + uint32_t general_progressive_source_flag : 1; + uint32_t general_interlaced_source_flag : 1; + uint32_t general_non_packed_constraint_flag : 1; + uint32_t general_frame_only_constraint_flag : 1; +} StdVideoH265ProfileTierLevelFlags; + +typedef struct StdVideoH265ProfileTierLevel { + StdVideoH265ProfileTierLevelFlags flags; + StdVideoH265ProfileIdc general_profile_idc; + StdVideoH265LevelIdc general_level_idc; +} StdVideoH265ProfileTierLevel; + +typedef struct StdVideoH265VideoParameterSet { + StdVideoH265VpsFlags flags; + uint8_t vps_video_parameter_set_id; + uint8_t vps_max_sub_layers_minus1; + uint8_t reserved1; + uint8_t reserved2; + uint32_t vps_num_units_in_tick; + uint32_t vps_time_scale; + uint32_t vps_num_ticks_poc_diff_one_minus1; + uint32_t reserved3; + const StdVideoH265DecPicBufMgr* pDecPicBufMgr; + const StdVideoH265HrdParameters* pHrdParameters; + const StdVideoH265ProfileTierLevel* pProfileTierLevel; +} StdVideoH265VideoParameterSet; + +typedef struct StdVideoH265ScalingLists { + uint8_t ScalingList4x4[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS]; + uint8_t ScalingList8x8[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS]; + uint8_t ScalingList16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS]; + uint8_t ScalingList32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS]; + uint8_t ScalingListDCCoef16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS]; + uint8_t ScalingListDCCoef32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS]; +} StdVideoH265ScalingLists; + +typedef struct StdVideoH265SpsVuiFlags { + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t colour_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t neutral_chroma_indication_flag : 1; + uint32_t field_seq_flag : 1; + uint32_t frame_field_info_present_flag : 1; + uint32_t default_display_window_flag : 1; + uint32_t vui_timing_info_present_flag : 1; + uint32_t vui_poc_proportional_to_timing_flag : 1; + uint32_t vui_hrd_parameters_present_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t tiles_fixed_structure_flag : 1; + uint32_t motion_vectors_over_pic_boundaries_flag : 1; + uint32_t restricted_ref_pic_lists_flag : 1; +} StdVideoH265SpsVuiFlags; + +typedef struct StdVideoH265SequenceParameterSetVui { + StdVideoH265SpsVuiFlags flags; + StdVideoH265AspectRatioIdc aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coeffs; + uint8_t chroma_sample_loc_type_top_field; + uint8_t chroma_sample_loc_type_bottom_field; + uint8_t reserved1; + uint8_t reserved2; + uint16_t def_disp_win_left_offset; + uint16_t def_disp_win_right_offset; + uint16_t def_disp_win_top_offset; + uint16_t def_disp_win_bottom_offset; + uint32_t vui_num_units_in_tick; + uint32_t vui_time_scale; + uint32_t vui_num_ticks_poc_diff_one_minus1; + uint16_t min_spatial_segmentation_idc; + uint16_t reserved3; + uint8_t max_bytes_per_pic_denom; + uint8_t max_bits_per_min_cu_denom; + uint8_t log2_max_mv_length_horizontal; + uint8_t log2_max_mv_length_vertical; + const StdVideoH265HrdParameters* pHrdParameters; +} StdVideoH265SequenceParameterSetVui; + +typedef struct StdVideoH265PredictorPaletteEntries { + uint16_t PredictorPaletteEntries[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE]; +} StdVideoH265PredictorPaletteEntries; + +typedef struct StdVideoH265SpsFlags { + uint32_t sps_temporal_id_nesting_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t conformance_window_flag : 1; + uint32_t sps_sub_layer_ordering_info_present_flag : 1; + uint32_t scaling_list_enabled_flag : 1; + uint32_t sps_scaling_list_data_present_flag : 1; + uint32_t amp_enabled_flag : 1; + uint32_t sample_adaptive_offset_enabled_flag : 1; + uint32_t pcm_enabled_flag : 1; + uint32_t pcm_loop_filter_disabled_flag : 1; + uint32_t long_term_ref_pics_present_flag : 1; + uint32_t sps_temporal_mvp_enabled_flag : 1; + uint32_t strong_intra_smoothing_enabled_flag : 1; + uint32_t vui_parameters_present_flag : 1; + uint32_t sps_extension_present_flag : 1; + uint32_t sps_range_extension_flag : 1; + uint32_t transform_skip_rotation_enabled_flag : 1; + uint32_t transform_skip_context_enabled_flag : 1; + uint32_t implicit_rdpcm_enabled_flag : 1; + uint32_t explicit_rdpcm_enabled_flag : 1; + uint32_t extended_precision_processing_flag : 1; + uint32_t intra_smoothing_disabled_flag : 1; + uint32_t high_precision_offsets_enabled_flag : 1; + uint32_t persistent_rice_adaptation_enabled_flag : 1; + uint32_t cabac_bypass_alignment_enabled_flag : 1; + uint32_t sps_scc_extension_flag : 1; + uint32_t sps_curr_pic_ref_enabled_flag : 1; + uint32_t palette_mode_enabled_flag : 1; + uint32_t sps_palette_predictor_initializers_present_flag : 1; + uint32_t intra_boundary_filtering_disabled_flag : 1; +} StdVideoH265SpsFlags; + +typedef struct StdVideoH265ShortTermRefPicSetFlags { + uint32_t inter_ref_pic_set_prediction_flag : 1; + uint32_t delta_rps_sign : 1; +} StdVideoH265ShortTermRefPicSetFlags; + +typedef struct StdVideoH265ShortTermRefPicSet { + StdVideoH265ShortTermRefPicSetFlags flags; + uint32_t delta_idx_minus1; + uint16_t use_delta_flag; + uint16_t abs_delta_rps_minus1; + uint16_t used_by_curr_pic_flag; + uint16_t used_by_curr_pic_s0_flag; + uint16_t used_by_curr_pic_s1_flag; + uint16_t reserved1; + uint8_t reserved2; + uint8_t reserved3; + uint8_t num_negative_pics; + uint8_t num_positive_pics; + uint16_t delta_poc_s0_minus1[STD_VIDEO_H265_MAX_DPB_SIZE]; + uint16_t delta_poc_s1_minus1[STD_VIDEO_H265_MAX_DPB_SIZE]; +} StdVideoH265ShortTermRefPicSet; + +typedef struct StdVideoH265LongTermRefPicsSps { + uint32_t used_by_curr_pic_lt_sps_flag; + uint32_t lt_ref_pic_poc_lsb_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]; +} StdVideoH265LongTermRefPicsSps; + +typedef struct StdVideoH265SequenceParameterSet { + StdVideoH265SpsFlags flags; + StdVideoH265ChromaFormatIdc chroma_format_idc; + uint32_t pic_width_in_luma_samples; + uint32_t pic_height_in_luma_samples; + uint8_t sps_video_parameter_set_id; + uint8_t sps_max_sub_layers_minus1; + uint8_t sps_seq_parameter_set_id; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + uint8_t log2_min_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_luma_coding_block_size; + uint8_t log2_min_luma_transform_block_size_minus2; + uint8_t log2_diff_max_min_luma_transform_block_size; + uint8_t max_transform_hierarchy_depth_inter; + uint8_t max_transform_hierarchy_depth_intra; + uint8_t num_short_term_ref_pic_sets; + uint8_t num_long_term_ref_pics_sps; + uint8_t pcm_sample_bit_depth_luma_minus1; + uint8_t pcm_sample_bit_depth_chroma_minus1; + uint8_t log2_min_pcm_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_pcm_luma_coding_block_size; + uint8_t reserved1; + uint8_t reserved2; + uint8_t palette_max_size; + uint8_t delta_palette_max_predictor_size; + uint8_t motion_vector_resolution_control_idc; + uint8_t sps_num_palette_predictor_initializers_minus1; + uint32_t conf_win_left_offset; + uint32_t conf_win_right_offset; + uint32_t conf_win_top_offset; + uint32_t conf_win_bottom_offset; + const StdVideoH265ProfileTierLevel* pProfileTierLevel; + const StdVideoH265DecPicBufMgr* pDecPicBufMgr; + const StdVideoH265ScalingLists* pScalingLists; + const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; + const StdVideoH265LongTermRefPicsSps* pLongTermRefPicsSps; + const StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; + const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; +} StdVideoH265SequenceParameterSet; + +typedef struct StdVideoH265PpsFlags { + uint32_t dependent_slice_segments_enabled_flag : 1; + uint32_t output_flag_present_flag : 1; + uint32_t sign_data_hiding_enabled_flag : 1; + uint32_t cabac_init_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t transform_skip_enabled_flag : 1; + uint32_t cu_qp_delta_enabled_flag : 1; + uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t weighted_bipred_flag : 1; + uint32_t transquant_bypass_enabled_flag : 1; + uint32_t tiles_enabled_flag : 1; + uint32_t entropy_coding_sync_enabled_flag : 1; + uint32_t uniform_spacing_flag : 1; + uint32_t loop_filter_across_tiles_enabled_flag : 1; + uint32_t pps_loop_filter_across_slices_enabled_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t deblocking_filter_override_enabled_flag : 1; + uint32_t pps_deblocking_filter_disabled_flag : 1; + uint32_t pps_scaling_list_data_present_flag : 1; + uint32_t lists_modification_present_flag : 1; + uint32_t slice_segment_header_extension_present_flag : 1; + uint32_t pps_extension_present_flag : 1; + uint32_t cross_component_prediction_enabled_flag : 1; + uint32_t chroma_qp_offset_list_enabled_flag : 1; + uint32_t pps_curr_pic_ref_enabled_flag : 1; + uint32_t residual_adaptive_colour_transform_enabled_flag : 1; + uint32_t pps_slice_act_qp_offsets_present_flag : 1; + uint32_t pps_palette_predictor_initializers_present_flag : 1; + uint32_t monochrome_palette_flag : 1; + uint32_t pps_range_extension_flag : 1; +} StdVideoH265PpsFlags; + +typedef struct StdVideoH265PictureParameterSet { + StdVideoH265PpsFlags flags; + uint8_t pps_pic_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t sps_video_parameter_set_id; + uint8_t num_extra_slice_header_bits; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + int8_t init_qp_minus26; + uint8_t diff_cu_qp_delta_depth; + int8_t pps_cb_qp_offset; + int8_t pps_cr_qp_offset; + int8_t pps_beta_offset_div2; + int8_t pps_tc_offset_div2; + uint8_t log2_parallel_merge_level_minus2; + uint8_t log2_max_transform_skip_block_size_minus2; + uint8_t diff_cu_chroma_qp_offset_depth; + uint8_t chroma_qp_offset_list_len_minus1; + int8_t cb_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; + int8_t cr_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; + uint8_t log2_sao_offset_scale_luma; + uint8_t log2_sao_offset_scale_chroma; + int8_t pps_act_y_qp_offset_plus5; + int8_t pps_act_cb_qp_offset_plus5; + int8_t pps_act_cr_qp_offset_plus3; + uint8_t pps_num_palette_predictor_initializers; + uint8_t luma_bit_depth_entry_minus8; + uint8_t chroma_bit_depth_entry_minus8; + uint8_t num_tile_columns_minus1; + uint8_t num_tile_rows_minus1; + uint8_t reserved1; + uint8_t reserved2; + uint16_t column_width_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]; + uint16_t row_height_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]; + uint32_t reserved3; + const StdVideoH265ScalingLists* pScalingLists; + const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; +} StdVideoH265PictureParameterSet; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std_decode.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std_decode.h new file mode 100644 index 000000000..7eee9b389 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std_decode.h @@ -0,0 +1,65 @@ +#ifndef VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define vulkan_video_codec_h265std_decode 1 + +#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_decode" +typedef struct StdVideoDecodeH265PictureInfoFlags { + uint32_t IrapPicFlag : 1; + uint32_t IdrPicFlag : 1; + uint32_t IsReference : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; +} StdVideoDecodeH265PictureInfoFlags; + +typedef struct StdVideoDecodeH265PictureInfo { + StdVideoDecodeH265PictureInfoFlags flags; + uint8_t sps_video_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t pps_pic_parameter_set_id; + uint8_t NumDeltaPocsOfRefRpsIdx; + int32_t PicOrderCntVal; + uint16_t NumBitsForSTRefPicSetInSlice; + uint16_t reserved; + uint8_t RefPicSetStCurrBefore[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; + uint8_t RefPicSetStCurrAfter[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; + uint8_t RefPicSetLtCurr[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; +} StdVideoDecodeH265PictureInfo; + +typedef struct StdVideoDecodeH265ReferenceInfoFlags { + uint32_t used_for_long_term_reference : 1; + uint32_t unused_for_reference : 1; +} StdVideoDecodeH265ReferenceInfoFlags; + +typedef struct StdVideoDecodeH265ReferenceInfo { + StdVideoDecodeH265ReferenceInfoFlags flags; + int32_t PicOrderCntVal; +} StdVideoDecodeH265ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std_encode.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std_encode.h new file mode 100644 index 000000000..1a42b95e0 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codec_h265std_encode.h @@ -0,0 +1,150 @@ +#ifndef VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ +#define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define vulkan_video_codec_h265std_encode 1 +// Vulkan 0.9 provisional Vulkan video H.265 encode std specification version number +#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_10 VK_MAKE_VIDEO_STD_VERSION(0, 9, 10) + +#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_0_9_10 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_encode" +typedef struct StdVideoEncodeH265WeightTableFlags { + uint16_t luma_weight_l0_flag; + uint16_t chroma_weight_l0_flag; + uint16_t luma_weight_l1_flag; + uint16_t chroma_weight_l1_flag; +} StdVideoEncodeH265WeightTableFlags; + +typedef struct StdVideoEncodeH265WeightTable { + StdVideoEncodeH265WeightTableFlags flags; + uint8_t luma_log2_weight_denom; + int8_t delta_chroma_log2_weight_denom; + int8_t delta_luma_weight_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + int8_t luma_offset_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + int8_t delta_chroma_weight_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; + int8_t delta_chroma_offset_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; + int8_t delta_luma_weight_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + int8_t luma_offset_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + int8_t delta_chroma_weight_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; + int8_t delta_chroma_offset_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; +} StdVideoEncodeH265WeightTable; + +typedef struct StdVideoEncodeH265SliceSegmentHeaderFlags { + uint32_t first_slice_segment_in_pic_flag : 1; + uint32_t no_output_of_prior_pics_flag : 1; + uint32_t dependent_slice_segment_flag : 1; + uint32_t pic_output_flag : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; + uint32_t slice_temporal_mvp_enable_flag : 1; + uint32_t slice_sao_luma_flag : 1; + uint32_t slice_sao_chroma_flag : 1; + uint32_t num_ref_idx_active_override_flag : 1; + uint32_t mvd_l1_zero_flag : 1; + uint32_t cabac_init_flag : 1; + uint32_t cu_chroma_qp_offset_enabled_flag : 1; + uint32_t deblocking_filter_override_flag : 1; + uint32_t slice_deblocking_filter_disabled_flag : 1; + uint32_t collocated_from_l0_flag : 1; + uint32_t slice_loop_filter_across_slices_enabled_flag : 1; +} StdVideoEncodeH265SliceSegmentHeaderFlags; + +typedef struct StdVideoEncodeH265SliceSegmentLongTermRefPics { + uint8_t num_long_term_sps; + uint8_t num_long_term_pics; + uint8_t lt_idx_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]; + uint8_t poc_lsb_lt[STD_VIDEO_H265_MAX_LONG_TERM_PICS]; + uint16_t used_by_curr_pic_lt_flag; + uint8_t delta_poc_msb_present_flag[STD_VIDEO_H265_MAX_DELTA_POC]; + uint8_t delta_poc_msb_cycle_lt[STD_VIDEO_H265_MAX_DELTA_POC]; +} StdVideoEncodeH265SliceSegmentLongTermRefPics; + +typedef struct StdVideoEncodeH265SliceSegmentHeader { + StdVideoEncodeH265SliceSegmentHeaderFlags flags; + StdVideoH265SliceType slice_type; + uint32_t slice_segment_address; + uint8_t short_term_ref_pic_set_idx; + uint8_t collocated_ref_idx; + uint8_t num_ref_idx_l0_active_minus1; + uint8_t num_ref_idx_l1_active_minus1; + uint8_t MaxNumMergeCand; + int8_t slice_cb_qp_offset; + int8_t slice_cr_qp_offset; + int8_t slice_beta_offset_div2; + int8_t slice_tc_offset_div2; + int8_t slice_act_y_qp_offset; + int8_t slice_act_cb_qp_offset; + int8_t slice_act_cr_qp_offset; + const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; + const StdVideoEncodeH265SliceSegmentLongTermRefPics* pLongTermRefPics; + const StdVideoEncodeH265WeightTable* pWeightTable; +} StdVideoEncodeH265SliceSegmentHeader; + +typedef struct StdVideoEncodeH265ReferenceListsInfoFlags { + uint32_t ref_pic_list_modification_flag_l0 : 1; + uint32_t ref_pic_list_modification_flag_l1 : 1; +} StdVideoEncodeH265ReferenceListsInfoFlags; + +typedef struct StdVideoEncodeH265ReferenceListsInfo { + StdVideoEncodeH265ReferenceListsInfoFlags flags; + uint8_t num_ref_idx_l0_active_minus1; + uint8_t num_ref_idx_l1_active_minus1; + uint16_t reserved1; + const uint8_t* pRefPicList0Entries; + const uint8_t* pRefPicList1Entries; + const uint8_t* pRefList0Modifications; + const uint8_t* pRefList1Modifications; +} StdVideoEncodeH265ReferenceListsInfo; + +typedef struct StdVideoEncodeH265PictureInfoFlags { + uint32_t is_reference_flag : 1; + uint32_t IrapPicFlag : 1; + uint32_t long_term_flag : 1; + uint32_t discardable_flag : 1; + uint32_t cross_layer_bla_flag : 1; +} StdVideoEncodeH265PictureInfoFlags; + +typedef struct StdVideoEncodeH265PictureInfo { + StdVideoEncodeH265PictureInfoFlags flags; + StdVideoH265PictureType PictureType; + uint8_t sps_video_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t pps_pic_parameter_set_id; + uint8_t TemporalId; + int32_t PicOrderCntVal; +} StdVideoEncodeH265PictureInfo; + +typedef struct StdVideoEncodeH265ReferenceInfoFlags { + uint32_t used_for_long_term_reference : 1; + uint32_t unused_for_reference : 1; +} StdVideoEncodeH265ReferenceInfoFlags; + +typedef struct StdVideoEncodeH265ReferenceInfo { + StdVideoEncodeH265ReferenceInfoFlags flags; + StdVideoH265PictureType PictureType; + int32_t PicOrderCntVal; + uint8_t TemporalId; +} StdVideoEncodeH265ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codecs_common.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codecs_common.h new file mode 100644 index 000000000..f486d3ca3 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vk_video/vulkan_video_codecs_common.h @@ -0,0 +1,31 @@ +#ifndef VULKAN_VIDEO_CODECS_COMMON_H_ +#define VULKAN_VIDEO_CODECS_COMMON_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define vulkan_video_codecs_common 1 +#define VK_MAKE_VIDEO_STD_VERSION(major, minor, patch) \ + ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_icd.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_icd.h new file mode 100644 index 000000000..2cd6c3d33 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_icd.h @@ -0,0 +1,258 @@ +// +// File: vk_icd.h +// +/* + * Copyright (c) 2015-2023 LunarG, Inc. + * Copyright (c) 2015-2023 The Khronos Group Inc. + * Copyright (c) 2015-2023 Valve Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +#pragma once + +#include "vulkan.h" +#include + +// Loader-ICD version negotiation API. Versions add the following features: +// Version 0 - Initial. Doesn't support vk_icdGetInstanceProcAddr +// or vk_icdNegotiateLoaderICDInterfaceVersion. +// Version 1 - Add support for vk_icdGetInstanceProcAddr. +// Version 2 - Add Loader/ICD Interface version negotiation +// via vk_icdNegotiateLoaderICDInterfaceVersion. +// Version 3 - Add ICD creation/destruction of KHR_surface objects. +// Version 4 - Add unknown physical device extension querying via +// vk_icdGetPhysicalDeviceProcAddr. +// Version 5 - Tells ICDs that the loader is now paying attention to the +// application version of Vulkan passed into the ApplicationInfo +// structure during vkCreateInstance. This will tell the ICD +// that if the loader is older, it should automatically fail a +// call for any API version > 1.0. Otherwise, the loader will +// manually determine if it can support the expected version. +// Version 6 - Add support for vk_icdEnumerateAdapterPhysicalDevices. +// Version 7 - If an ICD supports any of the following functions, they must be +// queryable with vk_icdGetInstanceProcAddr: +// vk_icdNegotiateLoaderICDInterfaceVersion +// vk_icdGetPhysicalDeviceProcAddr +// vk_icdEnumerateAdapterPhysicalDevices (Windows only) +// In addition, these functions no longer need to be exported directly. +// This version allows drivers provided through the extension +// VK_LUNARG_direct_driver_loading be able to support the entire +// Driver-Loader interface. + +#define CURRENT_LOADER_ICD_INTERFACE_VERSION 7 +#define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0 +#define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4 + +// Old typedefs that don't follow a proper naming convention but are preserved for compatibility +typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion); +// This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this +// file directly, it won't be found. +#ifndef PFN_GetPhysicalDeviceProcAddr +typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName); +#endif + +// Typedefs for loader/ICD interface +typedef VkResult (VKAPI_PTR *PFN_vk_icdNegotiateLoaderICDInterfaceVersion)(uint32_t* pVersion); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); +#if defined(VK_USE_PLATFORM_WIN32_KHR) +typedef VkResult (VKAPI_PTR *PFN_vk_icdEnumerateAdapterPhysicalDevices)(VkInstance instance, LUID adapterLUID, + uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +#endif + +// Prototypes for loader/ICD interface +#if !defined(VK_NO_PROTOTYPES) +#ifdef __cplusplus +extern "C" { +#endif + VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pVersion); + VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName); + VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance instance, const char* pName); +#if defined(VK_USE_PLATFORM_WIN32_KHR) + VKAPI_ATTR VkResult VKAPI_CALL vk_icdEnumerateAdapterPhysicalDevices(VkInstance instance, LUID adapterLUID, + uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +#endif +#ifdef __cplusplus +} +#endif +#endif + +/* + * The ICD must reserve space for a pointer for the loader's dispatch + * table, at the start of . + * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro. + */ + +#define ICD_LOADER_MAGIC 0x01CDC0DE + +typedef union { + uintptr_t loaderMagic; + void *loaderData; +} VK_LOADER_DATA; + +static inline void set_loader_magic_value(void *pNewObject) { + VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; + loader_info->loaderMagic = ICD_LOADER_MAGIC; +} + +static inline bool valid_loader_magic_value(void *pNewObject) { + const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; + return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC; +} + +/* + * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that + * contains the platform-specific connection and surface information. + */ +typedef enum { + VK_ICD_WSI_PLATFORM_MIR, + VK_ICD_WSI_PLATFORM_WAYLAND, + VK_ICD_WSI_PLATFORM_WIN32, + VK_ICD_WSI_PLATFORM_XCB, + VK_ICD_WSI_PLATFORM_XLIB, + VK_ICD_WSI_PLATFORM_ANDROID, + VK_ICD_WSI_PLATFORM_MACOS, + VK_ICD_WSI_PLATFORM_IOS, + VK_ICD_WSI_PLATFORM_DISPLAY, + VK_ICD_WSI_PLATFORM_HEADLESS, + VK_ICD_WSI_PLATFORM_METAL, + VK_ICD_WSI_PLATFORM_DIRECTFB, + VK_ICD_WSI_PLATFORM_VI, + VK_ICD_WSI_PLATFORM_GGP, + VK_ICD_WSI_PLATFORM_SCREEN, + VK_ICD_WSI_PLATFORM_FUCHSIA, +} VkIcdWsiPlatform; + +typedef struct { + VkIcdWsiPlatform platform; +} VkIcdSurfaceBase; + +#ifdef VK_USE_PLATFORM_MIR_KHR +typedef struct { + VkIcdSurfaceBase base; + MirConnection *connection; + MirSurface *mirSurface; +} VkIcdSurfaceMir; +#endif // VK_USE_PLATFORM_MIR_KHR + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +typedef struct { + VkIcdSurfaceBase base; + struct wl_display *display; + struct wl_surface *surface; +} VkIcdSurfaceWayland; +#endif // VK_USE_PLATFORM_WAYLAND_KHR + +#ifdef VK_USE_PLATFORM_WIN32_KHR +typedef struct { + VkIcdSurfaceBase base; + HINSTANCE hinstance; + HWND hwnd; +} VkIcdSurfaceWin32; +#endif // VK_USE_PLATFORM_WIN32_KHR + +#ifdef VK_USE_PLATFORM_XCB_KHR +typedef struct { + VkIcdSurfaceBase base; + xcb_connection_t *connection; + xcb_window_t window; +} VkIcdSurfaceXcb; +#endif // VK_USE_PLATFORM_XCB_KHR + +#ifdef VK_USE_PLATFORM_XLIB_KHR +typedef struct { + VkIcdSurfaceBase base; + Display *dpy; + Window window; +} VkIcdSurfaceXlib; +#endif // VK_USE_PLATFORM_XLIB_KHR + +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT +typedef struct { + VkIcdSurfaceBase base; + IDirectFB *dfb; + IDirectFBSurface *surface; +} VkIcdSurfaceDirectFB; +#endif // VK_USE_PLATFORM_DIRECTFB_EXT + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +typedef struct { + VkIcdSurfaceBase base; + struct ANativeWindow *window; +} VkIcdSurfaceAndroid; +#endif // VK_USE_PLATFORM_ANDROID_KHR + +#ifdef VK_USE_PLATFORM_MACOS_MVK +typedef struct { + VkIcdSurfaceBase base; + const void *pView; +} VkIcdSurfaceMacOS; +#endif // VK_USE_PLATFORM_MACOS_MVK + +#ifdef VK_USE_PLATFORM_IOS_MVK +typedef struct { + VkIcdSurfaceBase base; + const void *pView; +} VkIcdSurfaceIOS; +#endif // VK_USE_PLATFORM_IOS_MVK + +#ifdef VK_USE_PLATFORM_GGP +typedef struct { + VkIcdSurfaceBase base; + GgpStreamDescriptor streamDescriptor; +} VkIcdSurfaceGgp; +#endif // VK_USE_PLATFORM_GGP + +typedef struct { + VkIcdSurfaceBase base; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkIcdSurfaceDisplay; + +typedef struct { + VkIcdSurfaceBase base; +} VkIcdSurfaceHeadless; + +#ifdef VK_USE_PLATFORM_METAL_EXT +typedef struct { + VkIcdSurfaceBase base; + const CAMetalLayer *pLayer; +} VkIcdSurfaceMetal; +#endif // VK_USE_PLATFORM_METAL_EXT + +#ifdef VK_USE_PLATFORM_VI_NN +typedef struct { + VkIcdSurfaceBase base; + void *window; +} VkIcdSurfaceVi; +#endif // VK_USE_PLATFORM_VI_NN + +#ifdef VK_USE_PLATFORM_SCREEN_QNX +typedef struct { + VkIcdSurfaceBase base; + struct _screen_context *context; + struct _screen_window *window; +} VkIcdSurfaceScreen; +#endif // VK_USE_PLATFORM_SCREEN_QNX + +#ifdef VK_USE_PLATFORM_FUCHSIA +typedef struct { + VkIcdSurfaceBase base; +} VkIcdSurfaceImagePipe; +#endif // VK_USE_PLATFORM_FUCHSIA diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_layer.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_layer.h new file mode 100644 index 000000000..7954f71d8 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_layer.h @@ -0,0 +1,203 @@ +// +// File: vk_layer.h +// +/* + * Copyright (c) 2015-2023 LunarG, Inc. + * Copyright (c) 2015-2023 The Khronos Group Inc. + * Copyright (c) 2015-2023 Valve Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +#pragma once + +/* Need to define dispatch table + * Core struct can then have ptr to dispatch table at the top + * Along with object ptrs for current and next OBJ + */ + +#include "vulkan_core.h" + +#define MAX_NUM_UNKNOWN_EXTS 250 + + // Loader-Layer version negotiation API. Versions add the following features: + // Versions 0/1 - Initial. Doesn't support vk_layerGetPhysicalDeviceProcAddr + // or vk_icdNegotiateLoaderLayerInterfaceVersion. + // Version 2 - Add support for vk_layerGetPhysicalDeviceProcAddr and + // vk_icdNegotiateLoaderLayerInterfaceVersion. +#define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2 +#define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1 + +#define VK_CURRENT_CHAIN_VERSION 1 + +// Typedef for use in the interfaces below +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); + +// Version negotiation values +typedef enum VkNegotiateLayerStructType { + LAYER_NEGOTIATE_UNINTIALIZED = 0, + LAYER_NEGOTIATE_INTERFACE_STRUCT = 1, +} VkNegotiateLayerStructType; + +// Version negotiation structures +typedef struct VkNegotiateLayerInterface { + VkNegotiateLayerStructType sType; + void *pNext; + uint32_t loaderLayerInterfaceVersion; + PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr; + PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr; +} VkNegotiateLayerInterface; + +// Version negotiation functions +typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct); + +// Function prototype for unknown physical device extension command +typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device); + +// ------------------------------------------------------------------------------------------------ +// CreateInstance and CreateDevice support structures + +/* Sub type of structure for instance and device loader ext of CreateInfo. + * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO + * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO + * then VkLayerFunction indicates struct type pointed to by pNext + */ +typedef enum VkLayerFunction_ { + VK_LAYER_LINK_INFO = 0, + VK_LOADER_DATA_CALLBACK = 1, + VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2, + VK_LOADER_FEATURES = 3, +} VkLayerFunction; + +typedef struct VkLayerInstanceLink_ { + struct VkLayerInstanceLink_ *pNext; + PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; + PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr; +} VkLayerInstanceLink; + +/* + * When creating the device chain the loader needs to pass + * down information about it's device structure needed at + * the end of the chain. Passing the data via the + * VkLayerDeviceInfo avoids issues with finding the + * exact instance being used. + */ +typedef struct VkLayerDeviceInfo_ { + void *device_info; + PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; +} VkLayerDeviceInfo; + +typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance, + void *object); +typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device, + void *object); +typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA); +typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction); + +typedef enum VkLoaderFeastureFlagBits { + VK_LOADER_FEATURE_PHYSICAL_DEVICE_SORTING = 0x00000001, +} VkLoaderFlagBits; +typedef VkFlags VkLoaderFeatureFlags; + +typedef struct { + VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO + const void *pNext; + VkLayerFunction function; + union { + VkLayerInstanceLink *pLayerInfo; + PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData; + struct { + PFN_vkLayerCreateDevice pfnLayerCreateDevice; + PFN_vkLayerDestroyDevice pfnLayerDestroyDevice; + } layerDevice; + VkLoaderFeatureFlags loaderFeatures; + } u; +} VkLayerInstanceCreateInfo; + +typedef struct VkLayerDeviceLink_ { + struct VkLayerDeviceLink_ *pNext; + PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr; +} VkLayerDeviceLink; + +typedef struct { + VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO + const void *pNext; + VkLayerFunction function; + union { + VkLayerDeviceLink *pLayerInfo; + PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData; + } u; +} VkLayerDeviceCreateInfo; + +#ifdef __cplusplus +extern "C" { +#endif + +VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct); + +typedef enum VkChainType { + VK_CHAIN_TYPE_UNKNOWN = 0, + VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1, + VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2, + VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3, +} VkChainType; + +typedef struct VkChainHeader { + VkChainType type; + uint32_t version; + uint32_t size; +} VkChainHeader; + +typedef struct VkEnumerateInstanceExtensionPropertiesChain { + VkChainHeader header; + VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *, + VkExtensionProperties *); + const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink; + +#if defined(__cplusplus) + inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const { + return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties); + } +#endif +} VkEnumerateInstanceExtensionPropertiesChain; + +typedef struct VkEnumerateInstanceLayerPropertiesChain { + VkChainHeader header; + VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *); + const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink; + +#if defined(__cplusplus) + inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const { + return pfnNextLayer(pNextLink, pPropertyCount, pProperties); + } +#endif +} VkEnumerateInstanceLayerPropertiesChain; + +typedef struct VkEnumerateInstanceVersionChain { + VkChainHeader header; + VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *); + const struct VkEnumerateInstanceVersionChain *pNextLink; + +#if defined(__cplusplus) + inline VkResult CallDown(uint32_t *pApiVersion) const { + return pfnNextLayer(pNextLink, pApiVersion); + } +#endif +} VkEnumerateInstanceVersionChain; + +#ifdef __cplusplus +} +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_platform.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_platform.h new file mode 100644 index 000000000..ed67a6004 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vk_platform.h @@ -0,0 +1,84 @@ +// +// File: vk_platform.h +// +/* +** Copyright 2014-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + + +#ifndef VK_PLATFORM_H_ +#define VK_PLATFORM_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +/* +*************************************************************************************************** +* Platform-specific directives and type declarations +*************************************************************************************************** +*/ + +/* Platform-specific calling convention macros. + * + * Platforms should define these so that Vulkan clients call Vulkan commands + * with the same calling conventions that the Vulkan implementation expects. + * + * VKAPI_ATTR - Placed before the return type in function declarations. + * Useful for C++11 and GCC/Clang-style function attribute syntax. + * VKAPI_CALL - Placed after the return type in function declarations. + * Useful for MSVC-style calling convention syntax. + * VKAPI_PTR - Placed between the '(' and '*' in function pointer types. + * + * Function declaration: VKAPI_ATTR void VKAPI_CALL vkCommand(void); + * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void); + */ +#if defined(_WIN32) + // On Windows, Vulkan commands use the stdcall convention + #define VKAPI_ATTR + #define VKAPI_CALL __stdcall + #define VKAPI_PTR VKAPI_CALL +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7 + #error "Vulkan is not supported for the 'armeabi' NDK ABI" +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE) + // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat" + // calling convention, i.e. float parameters are passed in registers. This + // is true even if the rest of the application passes floats on the stack, + // as it does by default when compiling for the armeabi-v7a NDK ABI. + #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp"))) + #define VKAPI_CALL + #define VKAPI_PTR VKAPI_ATTR +#else + // On other platforms, use the default calling convention + #define VKAPI_ATTR + #define VKAPI_CALL + #define VKAPI_PTR +#endif + +#if !defined(VK_NO_STDDEF_H) + #include +#endif // !defined(VK_NO_STDDEF_H) + +#if !defined(VK_NO_STDINT_H) + #if defined(_MSC_VER) && (_MSC_VER < 1600) + typedef signed __int8 int8_t; + typedef unsigned __int8 uint8_t; + typedef signed __int16 int16_t; + typedef unsigned __int16 uint16_t; + typedef signed __int32 int32_t; + typedef unsigned __int32 uint32_t; + typedef signed __int64 int64_t; + typedef unsigned __int64 uint64_t; + #else + #include + #endif +#endif // !defined(VK_NO_STDINT_H) + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan.h new file mode 100644 index 000000000..426cff58d --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan.h @@ -0,0 +1,99 @@ +#ifndef VULKAN_H_ +#define VULKAN_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#include "vk_platform.h" +#include "vulkan_core.h" + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +#include "vulkan_android.h" +#endif + +#ifdef VK_USE_PLATFORM_FUCHSIA +#include +#include "vulkan_fuchsia.h" +#endif + +#ifdef VK_USE_PLATFORM_IOS_MVK +#include "vulkan_ios.h" +#endif + + +#ifdef VK_USE_PLATFORM_MACOS_MVK +#include "vulkan_macos.h" +#endif + +#ifdef VK_USE_PLATFORM_METAL_EXT +#include "vulkan_metal.h" +#endif + +#ifdef VK_USE_PLATFORM_VI_NN +#include "vulkan_vi.h" +#endif + + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +#include "vulkan_wayland.h" +#endif + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#include +#include "vulkan_win32.h" +#endif + + +#ifdef VK_USE_PLATFORM_XCB_KHR +#include +#include "vulkan_xcb.h" +#endif + + +#ifdef VK_USE_PLATFORM_XLIB_KHR +#include +#include "vulkan_xlib.h" +#endif + + +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT +#include +#include "vulkan_directfb.h" +#endif + + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT +#include +#include +#include "vulkan_xlib_xrandr.h" +#endif + + +#ifdef VK_USE_PLATFORM_GGP +#include +#include "vulkan_ggp.h" +#endif + + +#ifdef VK_USE_PLATFORM_SCREEN_QNX +#include +#include "vulkan_screen.h" +#endif + + +#ifdef VK_USE_PLATFORM_SCI +#include +#include +#include "vulkan_sci.h" +#endif + + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#include "vulkan_beta.h" +#endif + +#endif // VULKAN_H_ diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_android.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_android.h new file mode 100644 index 000000000..2e1dfa9ba --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_android.h @@ -0,0 +1,125 @@ +#ifndef VULKAN_ANDROID_H_ +#define VULKAN_ANDROID_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_KHR_android_surface 1 +struct ANativeWindow; +#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 +#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" +typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; +typedef struct VkAndroidSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkAndroidSurfaceCreateFlagsKHR flags; + struct ANativeWindow* window; +} VkAndroidSurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( + VkInstance instance, + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + + +#define VK_ANDROID_external_memory_android_hardware_buffer 1 +struct AHardwareBuffer; +#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 5 +#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer" +typedef struct VkAndroidHardwareBufferUsageANDROID { + VkStructureType sType; + void* pNext; + uint64_t androidHardwareBufferUsage; +} VkAndroidHardwareBufferUsageANDROID; + +typedef struct VkAndroidHardwareBufferPropertiesANDROID { + VkStructureType sType; + void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; +} VkAndroidHardwareBufferPropertiesANDROID; + +typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID { + VkStructureType sType; + void* pNext; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; +} VkAndroidHardwareBufferFormatPropertiesANDROID; + +typedef struct VkImportAndroidHardwareBufferInfoANDROID { + VkStructureType sType; + const void* pNext; + struct AHardwareBuffer* buffer; +} VkImportAndroidHardwareBufferInfoANDROID; + +typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkMemoryGetAndroidHardwareBufferInfoANDROID; + +typedef struct VkExternalFormatANDROID { + VkStructureType sType; + void* pNext; + uint64_t externalFormat; +} VkExternalFormatANDROID; + +typedef struct VkAndroidHardwareBufferFormatProperties2ANDROID { + VkStructureType sType; + void* pNext; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags2 formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; +} VkAndroidHardwareBufferFormatProperties2ANDROID; + +typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID( + VkDevice device, + const struct AHardwareBuffer* buffer, + VkAndroidHardwareBufferPropertiesANDROID* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID( + VkDevice device, + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, + struct AHardwareBuffer** pBuffer); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_beta.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_beta.h new file mode 100644 index 000000000..b0729cc37 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_beta.h @@ -0,0 +1,537 @@ +#ifndef VULKAN_BETA_H_ +#define VULKAN_BETA_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_KHR_portability_subset 1 +#define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1 +#define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset" +typedef struct VkPhysicalDevicePortabilitySubsetFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 constantAlphaColorBlendFactors; + VkBool32 events; + VkBool32 imageViewFormatReinterpretation; + VkBool32 imageViewFormatSwizzle; + VkBool32 imageView2DOn3DImage; + VkBool32 multisampleArrayImage; + VkBool32 mutableComparisonSamplers; + VkBool32 pointPolygons; + VkBool32 samplerMipLodBias; + VkBool32 separateStencilMaskRef; + VkBool32 shaderSampleRateInterpolationFunctions; + VkBool32 tessellationIsolines; + VkBool32 tessellationPointMode; + VkBool32 triangleFans; + VkBool32 vertexAttributeAccessBeyondStride; +} VkPhysicalDevicePortabilitySubsetFeaturesKHR; + +typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t minVertexInputBindingStrideAlignment; +} VkPhysicalDevicePortabilitySubsetPropertiesKHR; + + + +#define VK_KHR_video_encode_queue 1 +#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 8 +#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue" + +typedef enum VkVideoEncodeTuningModeKHR { + VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1, + VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2, + VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3, + VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4, + VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeTuningModeKHR; +typedef VkFlags VkVideoEncodeFlagsKHR; + +typedef enum VkVideoEncodeCapabilityFlagBitsKHR { + VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeCapabilityFlagBitsKHR; +typedef VkFlags VkVideoEncodeCapabilityFlagsKHR; + +typedef enum VkVideoEncodeRateControlModeFlagBitsKHR { + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeRateControlModeFlagBitsKHR; +typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; + +typedef enum VkVideoEncodeFeedbackFlagBitsKHR { + VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeFeedbackFlagBitsKHR; +typedef VkFlags VkVideoEncodeFeedbackFlagsKHR; + +typedef enum VkVideoEncodeUsageFlagBitsKHR { + VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeUsageFlagBitsKHR; +typedef VkFlags VkVideoEncodeUsageFlagsKHR; + +typedef enum VkVideoEncodeContentFlagBitsKHR { + VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeContentFlagBitsKHR; +typedef VkFlags VkVideoEncodeContentFlagsKHR; +typedef VkFlags VkVideoEncodeRateControlFlagsKHR; +typedef struct VkVideoEncodeInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeFlagsKHR flags; + uint32_t qualityLevel; + VkBuffer dstBuffer; + VkDeviceSize dstBufferOffset; + VkDeviceSize dstBufferRange; + VkVideoPictureResourceInfoKHR srcPictureResource; + const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotInfoKHR* pReferenceSlots; + uint32_t precedingExternallyEncodedBytes; +} VkVideoEncodeInfoKHR; + +typedef struct VkVideoEncodeCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeCapabilityFlagsKHR flags; + VkVideoEncodeRateControlModeFlagsKHR rateControlModes; + uint32_t maxRateControlLayers; + uint32_t maxQualityLevels; + VkExtent2D inputImageDataFillAlignment; + VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; +} VkVideoEncodeCapabilitiesKHR; + +typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; +} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR; + +typedef struct VkVideoEncodeUsageInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeUsageFlagsKHR videoUsageHints; + VkVideoEncodeContentFlagsKHR videoContentHints; + VkVideoEncodeTuningModeKHR tuningMode; +} VkVideoEncodeUsageInfoKHR; + +typedef struct VkVideoEncodeRateControlLayerInfoKHR { + VkStructureType sType; + const void* pNext; + uint64_t averageBitrate; + uint64_t maxBitrate; + uint32_t frameRateNumerator; + uint32_t frameRateDenominator; + uint32_t virtualBufferSizeInMs; + uint32_t initialVirtualBufferSizeInMs; +} VkVideoEncodeRateControlLayerInfoKHR; + +typedef struct VkVideoEncodeRateControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeRateControlFlagsKHR flags; + VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; + uint32_t layerCount; + const VkVideoEncodeRateControlLayerInfoKHR* pLayers; +} VkVideoEncodeRateControlInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoEncodeInfoKHR* pEncodeInfo); +#endif + + +#define VK_EXT_video_encode_h264 1 +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_encode.h" +#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 10 +#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264" + +typedef enum VkVideoEncodeH264RateControlStructureEXT { + VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH264RateControlStructureEXT; + +typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT { + VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_ENABLED_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_DISABLED_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT = 0x00000008, + VK_VIDEO_ENCODE_H264_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000010, + VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020, + VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0x00000040, + VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0x00000080, + VK_VIDEO_ENCODE_H264_CAPABILITY_PIC_INIT_QP_MINUS26_BIT_EXT = 0x00000100, + VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00000200, + VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_EXPLICIT_BIT_EXT = 0x00000400, + VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_IMPLICIT_BIT_EXT = 0x00000800, + VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00001000, + VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0x00002000, + VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00004000, + VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00008000, + VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00010000, + VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00020000, + VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00040000, + VK_VIDEO_ENCODE_H264_CAPABILITY_DISABLE_DIRECT_SPATIAL_MV_PRED_BIT_EXT = 0x00080000, + VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00100000, + VK_VIDEO_ENCODE_H264_CAPABILITY_SLICE_MB_COUNT_BIT_EXT = 0x00200000, + VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0x00400000, + VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x00800000, + VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x01000000, + VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_REFERENCE_FINAL_LISTS_BIT_EXT = 0x02000000, + VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH264CapabilityFlagBitsEXT; +typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT; +typedef struct VkVideoEncodeH264CapabilitiesEXT { + VkStructureType sType; + void* pNext; + VkVideoEncodeH264CapabilityFlagsEXT flags; + uint32_t maxPPictureL0ReferenceCount; + uint32_t maxBPictureL0ReferenceCount; + uint32_t maxL1ReferenceCount; + VkBool32 motionVectorsOverPicBoundariesFlag; + uint32_t maxBytesPerPicDenom; + uint32_t maxBitsPerMbDenom; + uint32_t log2MaxMvLengthHorizontal; + uint32_t log2MaxMvLengthVertical; +} VkVideoEncodeH264CapabilitiesEXT; + +typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t stdSPSCount; + const StdVideoH264SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH264PictureParameterSet* pStdPPSs; +} VkVideoEncodeH264SessionParametersAddInfoEXT; + +typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo; +} VkVideoEncodeH264SessionParametersCreateInfoEXT; + +typedef struct VkVideoEncodeH264NaluSliceInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t mbCount; + const StdVideoEncodeH264ReferenceListsInfo* pStdReferenceFinalLists; + const StdVideoEncodeH264SliceHeader* pStdSliceHeader; +} VkVideoEncodeH264NaluSliceInfoEXT; + +typedef struct VkVideoEncodeH264VclFrameInfoEXT { + VkStructureType sType; + const void* pNext; + const StdVideoEncodeH264ReferenceListsInfo* pStdReferenceFinalLists; + uint32_t naluSliceEntryCount; + const VkVideoEncodeH264NaluSliceInfoEXT* pNaluSliceEntries; + const StdVideoEncodeH264PictureInfo* pStdPictureInfo; +} VkVideoEncodeH264VclFrameInfoEXT; + +typedef struct VkVideoEncodeH264DpbSlotInfoEXT { + VkStructureType sType; + const void* pNext; + const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo; +} VkVideoEncodeH264DpbSlotInfoEXT; + +typedef struct VkVideoEncodeH264ProfileInfoEXT { + VkStructureType sType; + const void* pNext; + StdVideoH264ProfileIdc stdProfileIdc; +} VkVideoEncodeH264ProfileInfoEXT; + +typedef struct VkVideoEncodeH264RateControlInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + VkVideoEncodeH264RateControlStructureEXT rateControlStructure; + uint32_t temporalLayerCount; +} VkVideoEncodeH264RateControlInfoEXT; + +typedef struct VkVideoEncodeH264QpEXT { + int32_t qpI; + int32_t qpP; + int32_t qpB; +} VkVideoEncodeH264QpEXT; + +typedef struct VkVideoEncodeH264FrameSizeEXT { + uint32_t frameISize; + uint32_t framePSize; + uint32_t frameBSize; +} VkVideoEncodeH264FrameSizeEXT; + +typedef struct VkVideoEncodeH264RateControlLayerInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t temporalLayerId; + VkBool32 useInitialRcQp; + VkVideoEncodeH264QpEXT initialRcQp; + VkBool32 useMinQp; + VkVideoEncodeH264QpEXT minQp; + VkBool32 useMaxQp; + VkVideoEncodeH264QpEXT maxQp; + VkBool32 useMaxFrameSize; + VkVideoEncodeH264FrameSizeEXT maxFrameSize; +} VkVideoEncodeH264RateControlLayerInfoEXT; + + + +#define VK_EXT_video_encode_h265 1 +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_encode.h" +#define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 10 +#define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265" + +typedef enum VkVideoEncodeH265RateControlStructureEXT { + VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH265RateControlStructureEXT; + +typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT { + VK_VIDEO_ENCODE_H265_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H265_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H265_CAPABILITY_SAMPLE_ADAPTIVE_OFFSET_ENABLED_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H265_CAPABILITY_PCM_ENABLE_BIT_EXT = 0x00000008, + VK_VIDEO_ENCODE_H265_CAPABILITY_SPS_TEMPORAL_MVP_ENABLED_BIT_EXT = 0x00000010, + VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020, + VK_VIDEO_ENCODE_H265_CAPABILITY_INIT_QP_MINUS26_BIT_EXT = 0x00000040, + VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0x00000080, + VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT = 0x00000100, + VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT = 0x00000200, + VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT = 0x00000400, + VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT = 0x00000800, + VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00001000, + VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT = 0x00002000, + VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00004000, + VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT = 0x00008000, + VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT = 0x00010000, + VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT = 0x00020000, + VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT = 0x00040000, + VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT = 0x00080000, + VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT = 0x00100000, + VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT = 0x00200000, + VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00400000, + VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT = 0x00800000, + VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x01000000, + VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x02000000, + VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_REFERENCE_FINAL_LISTS_BIT_EXT = 0x04000000, + VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH265CapabilityFlagBitsEXT; +typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT; + +typedef enum VkVideoEncodeH265CtbSizeFlagBitsEXT { + VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH265CtbSizeFlagBitsEXT; +typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT; + +typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsEXT { + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT = 0x00000001, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT = 0x00000002, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT = 0x00000004, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT = 0x00000008, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkVideoEncodeH265TransformBlockSizeFlagBitsEXT; +typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT; +typedef struct VkVideoEncodeH265CapabilitiesEXT { + VkStructureType sType; + void* pNext; + VkVideoEncodeH265CapabilityFlagsEXT flags; + VkVideoEncodeH265CtbSizeFlagsEXT ctbSizes; + VkVideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes; + uint32_t maxPPictureL0ReferenceCount; + uint32_t maxBPictureL0ReferenceCount; + uint32_t maxL1ReferenceCount; + uint32_t maxSubLayersCount; + uint32_t minLog2MinLumaCodingBlockSizeMinus3; + uint32_t maxLog2MinLumaCodingBlockSizeMinus3; + uint32_t minLog2MinLumaTransformBlockSizeMinus2; + uint32_t maxLog2MinLumaTransformBlockSizeMinus2; + uint32_t minMaxTransformHierarchyDepthInter; + uint32_t maxMaxTransformHierarchyDepthInter; + uint32_t minMaxTransformHierarchyDepthIntra; + uint32_t maxMaxTransformHierarchyDepthIntra; + uint32_t maxDiffCuQpDeltaDepth; + uint32_t minMaxNumMergeCand; + uint32_t maxMaxNumMergeCand; +} VkVideoEncodeH265CapabilitiesEXT; + +typedef struct VkVideoEncodeH265SessionParametersAddInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t stdVPSCount; + const StdVideoH265VideoParameterSet* pStdVPSs; + uint32_t stdSPSCount; + const StdVideoH265SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH265PictureParameterSet* pStdPPSs; +} VkVideoEncodeH265SessionParametersAddInfoEXT; + +typedef struct VkVideoEncodeH265SessionParametersCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t maxStdVPSCount; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoEncodeH265SessionParametersAddInfoEXT* pParametersAddInfo; +} VkVideoEncodeH265SessionParametersCreateInfoEXT; + +typedef struct VkVideoEncodeH265NaluSliceSegmentInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t ctbCount; + const StdVideoEncodeH265ReferenceListsInfo* pStdReferenceFinalLists; + const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader; +} VkVideoEncodeH265NaluSliceSegmentInfoEXT; + +typedef struct VkVideoEncodeH265VclFrameInfoEXT { + VkStructureType sType; + const void* pNext; + const StdVideoEncodeH265ReferenceListsInfo* pStdReferenceFinalLists; + uint32_t naluSliceSegmentEntryCount; + const VkVideoEncodeH265NaluSliceSegmentInfoEXT* pNaluSliceSegmentEntries; + const StdVideoEncodeH265PictureInfo* pStdPictureInfo; +} VkVideoEncodeH265VclFrameInfoEXT; + +typedef struct VkVideoEncodeH265DpbSlotInfoEXT { + VkStructureType sType; + const void* pNext; + const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo; +} VkVideoEncodeH265DpbSlotInfoEXT; + +typedef struct VkVideoEncodeH265ProfileInfoEXT { + VkStructureType sType; + const void* pNext; + StdVideoH265ProfileIdc stdProfileIdc; +} VkVideoEncodeH265ProfileInfoEXT; + +typedef struct VkVideoEncodeH265RateControlInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + VkVideoEncodeH265RateControlStructureEXT rateControlStructure; + uint32_t subLayerCount; +} VkVideoEncodeH265RateControlInfoEXT; + +typedef struct VkVideoEncodeH265QpEXT { + int32_t qpI; + int32_t qpP; + int32_t qpB; +} VkVideoEncodeH265QpEXT; + +typedef struct VkVideoEncodeH265FrameSizeEXT { + uint32_t frameISize; + uint32_t framePSize; + uint32_t frameBSize; +} VkVideoEncodeH265FrameSizeEXT; + +typedef struct VkVideoEncodeH265RateControlLayerInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t temporalId; + VkBool32 useInitialRcQp; + VkVideoEncodeH265QpEXT initialRcQp; + VkBool32 useMinQp; + VkVideoEncodeH265QpEXT minQp; + VkBool32 useMaxQp; + VkVideoEncodeH265QpEXT maxQp; + VkBool32 useMaxFrameSize; + VkVideoEncodeH265FrameSizeEXT maxFrameSize; +} VkVideoEncodeH265RateControlLayerInfoEXT; + + + +#define VK_NV_displacement_micromap 1 +#define VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION 1 +#define VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME "VK_NV_displacement_micromap" + +typedef enum VkDisplacementMicromapFormatNV { + VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV = 1, + VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV = 2, + VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV = 3, + VK_DISPLACEMENT_MICROMAP_FORMAT_MAX_ENUM_NV = 0x7FFFFFFF +} VkDisplacementMicromapFormatNV; +typedef struct VkPhysicalDeviceDisplacementMicromapFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 displacementMicromap; +} VkPhysicalDeviceDisplacementMicromapFeaturesNV; + +typedef struct VkPhysicalDeviceDisplacementMicromapPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxDisplacementMicromapSubdivisionLevel; +} VkPhysicalDeviceDisplacementMicromapPropertiesNV; + +typedef struct VkAccelerationStructureTrianglesDisplacementMicromapNV { + VkStructureType sType; + void* pNext; + VkFormat displacementBiasAndScaleFormat; + VkFormat displacementVectorFormat; + VkDeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer; + VkDeviceSize displacementBiasAndScaleStride; + VkDeviceOrHostAddressConstKHR displacementVectorBuffer; + VkDeviceSize displacementVectorStride; + VkDeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags; + VkDeviceSize displacedMicromapPrimitiveFlagsStride; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts; + const VkMicromapUsageEXT* const* ppUsageCounts; + VkMicromapEXT micromap; +} VkAccelerationStructureTrianglesDisplacementMicromapNV; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_core.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_core.h new file mode 100644 index 000000000..e30fe49fd --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_core.h @@ -0,0 +1,17178 @@ +#ifndef VULKAN_CORE_H_ +#define VULKAN_CORE_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_VERSION_1_0 1 +#include "vk_platform.h" + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; + + +#ifndef VK_USE_64_BIT_PTR_DEFINES + #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_USE_64_BIT_PTR_DEFINES 1 + #else + #define VK_USE_64_BIT_PTR_DEFINES 0 + #endif +#endif + + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L)) + #define VK_NULL_HANDLE nullptr + #else + #define VK_NULL_HANDLE ((void*)0) + #endif + #else + #define VK_NULL_HANDLE 0ULL + #endif +#endif +#ifndef VK_NULL_HANDLE + #define VK_NULL_HANDLE 0 +#endif + + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; + #else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; + #endif +#endif + +#define VK_MAKE_API_VERSION(variant, major, minor, patch) \ + ((((uint32_t)(variant)) << 29U) | (((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch))) + +// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. +//#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 + +// Vulkan 1.0 version number +#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 + +// Version of this file +#define VK_HEADER_VERSION 247 + +// Complete version of this file +#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) + +// DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead. +#define VK_MAKE_VERSION(major, minor, patch) \ + ((((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch))) + +// DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead. +#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22U) + +// DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead. +#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) + +// DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead. +#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) + +#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29U) +#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22U) & 0x7FU) +#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) +#define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) +typedef uint32_t VkBool32; +typedef uint64_t VkDeviceAddress; +typedef uint64_t VkDeviceSize; +typedef uint32_t VkFlags; +typedef uint32_t VkSampleMask; +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) +VK_DEFINE_HANDLE(VkInstance) +VK_DEFINE_HANDLE(VkPhysicalDevice) +VK_DEFINE_HANDLE(VkDevice) +VK_DEFINE_HANDLE(VkQueue) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) +VK_DEFINE_HANDLE(VkCommandBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) +#define VK_ATTACHMENT_UNUSED (~0U) +#define VK_FALSE 0U +#define VK_LOD_CLAMP_NONE 1000.0F +#define VK_QUEUE_FAMILY_IGNORED (~0U) +#define VK_REMAINING_ARRAY_LAYERS (~0U) +#define VK_REMAINING_MIP_LEVELS (~0U) +#define VK_SUBPASS_EXTERNAL (~0U) +#define VK_TRUE 1U +#define VK_WHOLE_SIZE (~0ULL) +#define VK_MAX_MEMORY_TYPES 32U +#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256U +#define VK_UUID_SIZE 16U +#define VK_MAX_EXTENSION_NAME_SIZE 256U +#define VK_MAX_DESCRIPTION_SIZE 256U +#define VK_MAX_MEMORY_HEAPS 16U + +typedef enum VkResult { + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_FRAGMENTED_POOL = -12, + VK_ERROR_UNKNOWN = -13, + VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, + VK_ERROR_FRAGMENTATION = -1000161000, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, + VK_PIPELINE_COMPILE_REQUIRED = 1000297000, + VK_ERROR_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, + VK_ERROR_INVALID_SHADER_NV = -1000012000, + VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000, + VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001, + VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR = -1000023002, + VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR = -1000023003, + VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004, + VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005, + VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, + VK_ERROR_NOT_PERMITTED_KHR = -1000174001, + VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, + VK_THREAD_IDLE_KHR = 1000268000, + VK_THREAD_DONE_KHR = 1000268001, + VK_OPERATION_DEFERRED_KHR = 1000268002, + VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000, +#endif + VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, + VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, + VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, + VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, + VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, + VK_ERROR_NOT_PERMITTED_EXT = VK_ERROR_NOT_PERMITTED_KHR, + VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, + VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, + VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum VkStructureType { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, + VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54, + VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000, + VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001, + VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, + VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 = 1000314002, + VK_STRUCTURE_TYPE_DEPENDENCY_INFO = 1000314003, + VK_STRUCTURE_TYPE_SUBMIT_INFO_2 = 1000314004, + VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO = 1000314005, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO = 1000314006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000, + VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 = 1000337000, + VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 = 1000337001, + VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003, + VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005, + VK_STRUCTURE_TYPE_BUFFER_COPY_2 = 1000337006, + VK_STRUCTURE_TYPE_IMAGE_COPY_2 = 1000337007, + VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008, + VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 = 1000337009, + VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000, + VK_STRUCTURE_TYPE_RENDERING_INFO = 1000044000, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO = 1000044001, + VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO = 1000044002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001, + VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, + VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, + VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR = 1000023000, + VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001, + VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002, + VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003, + VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004, + VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005, + VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006, + VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007, + VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008, + VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009, + VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010, + VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012, + VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR = 1000023013, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014, + VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016, + VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR = 1000024002, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, + VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000, + VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001, + VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002, + VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038001, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038002, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038003, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT = 1000038005, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT = 1000038007, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT = 1000038008, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000039001, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039002, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT = 1000039003, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT = 1000039005, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT = 1000039007, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT = 1000039009, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010, +#endif + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000040004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000040005, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR = 1000040006, + VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, + VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, + VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008, + VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009, + VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, + VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT = 1000068000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT = 1000068001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT = 1000068002, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, + VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, + VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, + VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, + VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, + VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, + VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, + VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, + VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, + VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, + VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, + VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, + VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009, + VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010, + VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015, + VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, + VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, + VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001, +#endif + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, + VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, + VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, + VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, + VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, + VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, + VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, + VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, + VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, + VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000187002, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR = 1000187003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR = 1000187004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR = 1000187005, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = 1000174000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = 1000388000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, + VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, + VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, + VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002, + VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003, + VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004, + VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, + VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000, + VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001, + VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, + VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, + VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, + VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, + VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, + VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, + VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, + VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001, + VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002, + VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, + VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, + VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, + VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, + VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = 1000271000, + VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = 1000271001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = 1000274002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = 1000275000, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = 1000275001, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = 1000275002, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = 1000275003, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = 1000275004, + VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = 1000275005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, + VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000, + VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, + VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, + VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, + VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002, + VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR = 1000299005, +#endif + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, + VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, + VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000, + VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000, + VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001, + VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT = 1000311002, + VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT = 1000311003, + VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT = 1000311004, + VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT = 1000311005, + VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT = 1000311006, + VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT = 1000311007, + VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT = 1000311008, + VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT = 1000311009, + VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311010, + VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311011, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002, + VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003, + VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT = 1000316004, + VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005, + VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007, + VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008, + VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010, + VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011, + VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD = 1000321000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR = 1000203000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR = 1000322000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT = 1000328000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT = 1000328001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, + VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT = 1000338000, + VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT = 1000338001, + VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT = 1000338002, + VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT = 1000338003, + VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000, + VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT = 1000341001, + VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT = 1000341002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000, + VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, + VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, + VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000, + VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000, + VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001, + VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003, + VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005, + VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007, + VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009, + VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000, + VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001, + VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000, + VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001, + VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, + VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT = 1000395000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT = 1000395001, + VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000, + VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001, + VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002, + VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006, + VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT = 1000396007, + VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV = 1000397000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV = 1000397001, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV = 1000397002, +#endif + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, + VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = 1000421000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001, + VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = 1000427001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002, + VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003, + VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG = 1000459000, + VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG = 1000459001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002, + VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT = 1000462003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001, + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT = 1000482002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000, + VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000, + VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC = 1000485001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000, + VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, + VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + VK_STRUCTURE_TYPE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_INFO, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, + VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, + VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, + VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, + VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, + VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, + VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, + VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, + VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, + VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, + VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, + VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, + VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, + VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2, + VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2, + VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, + VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, + VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, + VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, + VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, + VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, + VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, + VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheHeaderVersion; + +typedef enum VkImageLayout { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, + VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000, + VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000, + VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001, + VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002, + VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, + VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, + VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002, +#endif + VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum VkObjectType { + VK_OBJECT_TYPE_UNKNOWN = 0, + VK_OBJECT_TYPE_INSTANCE = 1, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, + VK_OBJECT_TYPE_DEVICE = 3, + VK_OBJECT_TYPE_QUEUE = 4, + VK_OBJECT_TYPE_SEMAPHORE = 5, + VK_OBJECT_TYPE_COMMAND_BUFFER = 6, + VK_OBJECT_TYPE_FENCE = 7, + VK_OBJECT_TYPE_DEVICE_MEMORY = 8, + VK_OBJECT_TYPE_BUFFER = 9, + VK_OBJECT_TYPE_IMAGE = 10, + VK_OBJECT_TYPE_EVENT = 11, + VK_OBJECT_TYPE_QUERY_POOL = 12, + VK_OBJECT_TYPE_BUFFER_VIEW = 13, + VK_OBJECT_TYPE_IMAGE_VIEW = 14, + VK_OBJECT_TYPE_SHADER_MODULE = 15, + VK_OBJECT_TYPE_PIPELINE_CACHE = 16, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, + VK_OBJECT_TYPE_RENDER_PASS = 18, + VK_OBJECT_TYPE_PIPELINE = 19, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, + VK_OBJECT_TYPE_SAMPLER = 21, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, + VK_OBJECT_TYPE_FRAMEBUFFER = 24, + VK_OBJECT_TYPE_COMMAND_POOL = 25, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000, + VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, + VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, + VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, + VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, + VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000, + VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001, + VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000, + VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, + VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, + VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, + VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000, + VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000, + VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, + VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000, + VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, + VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, + VK_OBJECT_TYPE_SHADER_EXT = 1000482000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, + VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkObjectType; + +typedef enum VkVendorId { + VK_VENDOR_ID_VIV = 0x10001, + VK_VENDOR_ID_VSI = 0x10002, + VK_VENDOR_ID_KAZAN = 0x10003, + VK_VENDOR_ID_CODEPLAY = 0x10004, + VK_VENDOR_ID_MESA = 0x10005, + VK_VENDOR_ID_POCL = 0x10006, + VK_VENDOR_ID_MOBILEYE = 0x10007, + VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF +} VkVendorId; + +typedef enum VkSystemAllocationScope { + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocationScope; + +typedef enum VkInternalAllocationType { + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkInternalAllocationType; + +typedef enum VkFormat { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, + VK_FORMAT_G8_B8R8_2PLANE_444_UNORM = 1000330000, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002, + VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003, + VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000, + VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001, + VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000, + VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001, + VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002, + VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003, + VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004, + VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005, + VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006, + VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007, + VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008, + VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009, + VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010, + VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011, + VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012, + VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013, + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + VK_FORMAT_R16G16_S10_5_NV = 1000464000, + VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, + VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, + VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK, + VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK, + VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK, + VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK, + VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, + VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, + VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, + VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, + VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, + VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16, + VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16, + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum VkImageTiling { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum VkImageType { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum VkPhysicalDeviceType { + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum VkQueryType { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000, + VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, + VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, + VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR = 1000299000, +#endif + VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000, + VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR = 1000386001, + VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT = 1000396000, + VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT = 1000396001, + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum VkSharingMode { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum VkComponentSwizzle { + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkComponentSwizzle; + +typedef enum VkImageViewType { + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum VkBlendFactor { + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} VkBlendFactor; + +typedef enum VkBlendOp { + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_ZERO_EXT = 1000148000, + VK_BLEND_OP_SRC_EXT = 1000148001, + VK_BLEND_OP_DST_EXT = 1000148002, + VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + VK_BLEND_OP_DST_OVER_EXT = 1000148004, + VK_BLEND_OP_SRC_IN_EXT = 1000148005, + VK_BLEND_OP_DST_IN_EXT = 1000148006, + VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + VK_BLEND_OP_DST_OUT_EXT = 1000148008, + VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + VK_BLEND_OP_XOR_EXT = 1000148011, + VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + VK_BLEND_OP_SCREEN_EXT = 1000148013, + VK_BLEND_OP_OVERLAY_EXT = 1000148014, + VK_BLEND_OP_DARKEN_EXT = 1000148015, + VK_BLEND_OP_LIGHTEN_EXT = 1000148016, + VK_BLEND_OP_COLORDODGE_EXT = 1000148017, + VK_BLEND_OP_COLORBURN_EXT = 1000148018, + VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, + VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, + VK_BLEND_OP_EXCLUSION_EXT = 1000148022, + VK_BLEND_OP_INVERT_EXT = 1000148023, + VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, + VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, + VK_BLEND_OP_LINEARBURN_EXT = 1000148026, + VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + VK_BLEND_OP_PINLIGHT_EXT = 1000148029, + VK_BLEND_OP_HARDMIX_EXT = 1000148030, + VK_BLEND_OP_HSL_HUE_EXT = 1000148031, + VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, + VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + VK_BLEND_OP_PLUS_EXT = 1000148035, + VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + VK_BLEND_OP_MINUS_EXT = 1000148039, + VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + VK_BLEND_OP_CONTRAST_EXT = 1000148041, + VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, + VK_BLEND_OP_RED_EXT = 1000148043, + VK_BLEND_OP_GREEN_EXT = 1000148044, + VK_BLEND_OP_BLUE_EXT = 1000148045, + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum VkCompareOp { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum VkDynamicState { + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_CULL_MODE = 1000267000, + VK_DYNAMIC_STATE_FRONT_FACE = 1000267001, + VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002, + VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT = 1000267003, + VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT = 1000267004, + VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE = 1000267005, + VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE = 1000267006, + VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE = 1000267007, + VK_DYNAMIC_STATE_DEPTH_COMPARE_OP = 1000267008, + VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE = 1000267009, + VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE = 1000267010, + VK_DYNAMIC_STATE_STENCIL_OP = 1000267011, + VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE = 1000377001, + VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE = 1000377002, + VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004, + VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT = 1000099001, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT = 1000099002, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, + VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000, + VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, + VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, + VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000, + VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, + VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, + VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000, + VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, + VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, + VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, + VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, + VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002, + VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003, + VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004, + VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005, + VK_DYNAMIC_STATE_SAMPLE_MASK_EXT = 1000455006, + VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007, + VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT = 1000455008, + VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT = 1000455009, + VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010, + VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011, + VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012, + VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013, + VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014, + VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015, + VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017, + VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018, + VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019, + VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020, + VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021, + VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022, + VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023, + VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024, + VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025, + VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029, + VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030, + VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031, + VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032, + VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE, + VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE, + VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, + VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, + VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, + VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE, + VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE, + VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE, + VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP, + VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE, + VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE, + VK_DYNAMIC_STATE_STENCIL_OP_EXT = VK_DYNAMIC_STATE_STENCIL_OP, + VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE, + VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE, + VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE, + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + +typedef enum VkFrontFace { + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum VkVertexInputRate { + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputRate; + +typedef enum VkPrimitiveTopology { + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum VkPolygonMode { + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} VkPolygonMode; + +typedef enum VkStencilOp { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum VkLogicOp { + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum VkBorderColor { + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, + VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_CUBIC_EXT = 1000015000, + VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT, + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkFilter; + +typedef enum VkSamplerAddressMode { + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerAddressMode; + +typedef enum VkSamplerMipmapMode { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerMipmapMode; + +typedef enum VkDescriptorType { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000, + VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, + VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000, + VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001, + VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000, + VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, + VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = VK_DESCRIPTOR_TYPE_MUTABLE_EXT, + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum VkAttachmentLoadOp { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000, + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum VkAttachmentStoreOp { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_NONE = 1000301000, + VK_ATTACHMENT_STORE_OP_NONE_KHR = VK_ATTACHMENT_STORE_OP_NONE, + VK_ATTACHMENT_STORE_OP_NONE_QCOM = VK_ATTACHMENT_STORE_OP_NONE, + VK_ATTACHMENT_STORE_OP_NONE_EXT = VK_ATTACHMENT_STORE_OP_NONE, + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum VkPipelineBindPoint { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000, + VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003, + VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum VkCommandBufferLevel { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferLevel; + +typedef enum VkIndexType { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_NONE_KHR = 1000165000, + VK_INDEX_TYPE_UINT8_EXT = 1000265000, + VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR, + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum VkSubpassContents { + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassContents; + +typedef enum VkAccessFlagBits { + VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, + VK_ACCESS_INDEX_READ_BIT = 0x00000002, + VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, + VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, + VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, + VK_ACCESS_SHADER_READ_BIT = 0x00000020, + VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, + VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, + VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, + VK_ACCESS_HOST_READ_BIT = 0x00002000, + VK_ACCESS_HOST_WRITE_BIT = 0x00004000, + VK_ACCESS_MEMORY_READ_BIT = 0x00008000, + VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, + VK_ACCESS_NONE = 0, + VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000, + VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000, + VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000, + VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, + VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, + VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000, + VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000, + VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000, + VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000, + VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000, + VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000, + VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, + VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, + VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, + VK_ACCESS_NONE_KHR = VK_ACCESS_NONE, + VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAccessFlagBits; +typedef VkFlags VkAccessFlags; + +typedef enum VkImageAspectFlagBits { + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, + VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, + VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, + VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, + VK_IMAGE_ASPECT_NONE = 0, + VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080, + VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, + VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, + VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, + VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, + VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, + VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, + VK_IMAGE_ASPECT_NONE_KHR = VK_IMAGE_ASPECT_NONE, + VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageAspectFlagBits; +typedef VkFlags VkImageAspectFlags; + +typedef enum VkFormatFeatureFlagBits { + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, + VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, + VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, + VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000, + VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000, + VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000, + VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000, + VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000, + VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000, +#endif + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, + VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFormatFeatureFlagBits; +typedef VkFlags VkFormatFeatureFlags; + +typedef enum VkImageCreateFlagBits { + VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, + VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, + VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, + VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, + VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, + VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, + VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, + VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000, + VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000, + VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000, + VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, + VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, + VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, + VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageCreateFlagBits; +typedef VkFlags VkImageCreateFlags; + +typedef enum VkSampleCountFlagBits { + VK_SAMPLE_COUNT_1_BIT = 0x00000001, + VK_SAMPLE_COUNT_2_BIT = 0x00000002, + VK_SAMPLE_COUNT_4_BIT = 0x00000004, + VK_SAMPLE_COUNT_8_BIT = 0x00000008, + VK_SAMPLE_COUNT_16_BIT = 0x00000010, + VK_SAMPLE_COUNT_32_BIT = 0x00000020, + VK_SAMPLE_COUNT_64_BIT = 0x00000040, + VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSampleCountFlagBits; +typedef VkFlags VkSampleCountFlags; + +typedef enum VkImageUsageFlagBits { + VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, + VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, + VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400, + VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800, + VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000, + VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, + VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000, +#endif + VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000, + VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, + VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, + VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, + VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageUsageFlagBits; +typedef VkFlags VkImageUsageFlags; + +typedef enum VkInstanceCreateFlagBits { + VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR = 0x00000001, + VK_INSTANCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkInstanceCreateFlagBits; +typedef VkFlags VkInstanceCreateFlags; + +typedef enum VkMemoryHeapFlagBits { + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryHeapFlagBits; +typedef VkFlags VkMemoryHeapFlags; + +typedef enum VkMemoryPropertyFlagBits { + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, + VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, + VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, + VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040, + VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080, + VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0x00000100, + VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryPropertyFlagBits; +typedef VkFlags VkMemoryPropertyFlags; + +typedef enum VkQueueFlagBits { + VK_QUEUE_GRAPHICS_BIT = 0x00000001, + VK_QUEUE_COMPUTE_BIT = 0x00000002, + VK_QUEUE_TRANSFER_BIT = 0x00000004, + VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, + VK_QUEUE_PROTECTED_BIT = 0x00000010, + VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040, +#endif + VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100, + VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueueFlagBits; +typedef VkFlags VkQueueFlags; +typedef VkFlags VkDeviceCreateFlags; + +typedef enum VkDeviceQueueCreateFlagBits { + VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, + VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDeviceQueueCreateFlagBits; +typedef VkFlags VkDeviceQueueCreateFlags; + +typedef enum VkPipelineStageFlagBits { + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, + VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, + VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, + VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, + VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, + VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, + VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, + VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, + VK_PIPELINE_STAGE_NONE = 0, + VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000, + VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, + VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000, + VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000, + VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, + VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000, + VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT = 0x00080000, + VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT = 0x00100000, + VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, + VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, + VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, + VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE, + VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineStageFlagBits; +typedef VkFlags VkPipelineStageFlags; +typedef VkFlags VkMemoryMapFlags; + +typedef enum VkSparseMemoryBindFlagBits { + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseMemoryBindFlagBits; +typedef VkFlags VkSparseMemoryBindFlags; + +typedef enum VkSparseImageFormatFlagBits { + VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, + VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, + VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, + VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseImageFormatFlagBits; +typedef VkFlags VkSparseImageFormatFlags; + +typedef enum VkFenceCreateFlagBits { + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFenceCreateFlagBits; +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; + +typedef enum VkEventCreateFlagBits { + VK_EVENT_CREATE_DEVICE_ONLY_BIT = 0x00000001, + VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT, + VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkEventCreateFlagBits; +typedef VkFlags VkEventCreateFlags; + +typedef enum VkQueryPipelineStatisticFlagBits { + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, + VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, + VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, + VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, + VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT = 0x00000800, + VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT = 0x00001000, + VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI = 0x00002000, + VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryPipelineStatisticFlagBits; +typedef VkFlags VkQueryPipelineStatisticFlags; +typedef VkFlags VkQueryPoolCreateFlags; + +typedef enum VkQueryResultFlagBits { + VK_QUERY_RESULT_64_BIT = 0x00000001, + VK_QUERY_RESULT_WAIT_BIT = 0x00000002, + VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, + VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, + VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010, + VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryResultFlagBits; +typedef VkFlags VkQueryResultFlags; + +typedef enum VkBufferCreateFlagBits { + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010, + VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000020, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferCreateFlagBits; +typedef VkFlags VkBufferCreateFlags; + +typedef enum VkBufferUsageFlagBits { + VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, + VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, + VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000, + VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000, + VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000, + VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800, + VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, + VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, + VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000, + VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000, + VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000, +#endif + VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000, + VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000, + VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000, + VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000, + VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000, + VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferUsageFlagBits; +typedef VkFlags VkBufferUsageFlags; +typedef VkFlags VkBufferViewCreateFlags; + +typedef enum VkImageViewCreateFlagBits { + VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, + VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000004, + VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002, + VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageViewCreateFlagBits; +typedef VkFlags VkImageViewCreateFlags; +typedef VkFlags VkShaderModuleCreateFlags; + +typedef enum VkPipelineCacheCreateFlagBits { + VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001, + VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, + VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheCreateFlagBits; +typedef VkFlags VkPipelineCacheCreateFlags; + +typedef enum VkColorComponentFlagBits { + VK_COLOR_COMPONENT_R_BIT = 0x00000001, + VK_COLOR_COMPONENT_G_BIT = 0x00000002, + VK_COLOR_COMPONENT_B_BIT = 0x00000004, + VK_COLOR_COMPONENT_A_BIT = 0x00000008, + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkColorComponentFlagBits; +typedef VkFlags VkColorComponentFlags; + +typedef enum VkPipelineCreateFlagBits { + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, + VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010, + VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100, + VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200, + VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000, + VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000, + VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000, + VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000, + VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000, + VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020, + VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040, + VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080, + VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000, + VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800, + VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000, + VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000, + VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400, + VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000, + VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000, + VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000, + VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000, +#endif + VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000, + VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000, + VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, + VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, + VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCreateFlagBits; +typedef VkFlags VkPipelineCreateFlags; + +typedef enum VkPipelineShaderStageCreateFlagBits { + VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 0x00000001, + VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 0x00000002, + VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, + VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, + VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineShaderStageCreateFlagBits; +typedef VkFlags VkPipelineShaderStageCreateFlags; + +typedef enum VkShaderStageFlagBits { + VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, + VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, + VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, + VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, + VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, + VK_SHADER_STAGE_ALL = 0x7FFFFFFF, + VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100, + VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200, + VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400, + VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800, + VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000, + VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000, + VK_SHADER_STAGE_TASK_BIT_EXT = 0x00000040, + VK_SHADER_STAGE_MESH_BIT_EXT = 0x00000080, + VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000, + VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI = 0x00080000, + VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR, + VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR, + VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, + VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR, + VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR, + VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR, + VK_SHADER_STAGE_TASK_BIT_NV = VK_SHADER_STAGE_TASK_BIT_EXT, + VK_SHADER_STAGE_MESH_BIT_NV = VK_SHADER_STAGE_MESH_BIT_EXT, + VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkShaderStageFlagBits; + +typedef enum VkCullModeFlagBits { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 0x00000001, + VK_CULL_MODE_BACK_BIT = 0x00000002, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCullModeFlagBits; +typedef VkFlags VkCullModeFlags; +typedef VkFlags VkPipelineVertexInputStateCreateFlags; +typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; +typedef VkFlags VkPipelineTessellationStateCreateFlags; +typedef VkFlags VkPipelineViewportStateCreateFlags; +typedef VkFlags VkPipelineRasterizationStateCreateFlags; +typedef VkFlags VkPipelineMultisampleStateCreateFlags; + +typedef enum VkPipelineDepthStencilStateCreateFlagBits { + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000001, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000002, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineDepthStencilStateCreateFlagBits; +typedef VkFlags VkPipelineDepthStencilStateCreateFlags; + +typedef enum VkPipelineColorBlendStateCreateFlagBits { + VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT = 0x00000001, + VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT, + VK_PIPELINE_COLOR_BLEND_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineColorBlendStateCreateFlagBits; +typedef VkFlags VkPipelineColorBlendStateCreateFlags; +typedef VkFlags VkPipelineDynamicStateCreateFlags; + +typedef enum VkPipelineLayoutCreateFlagBits { + VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 0x00000002, + VK_PIPELINE_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineLayoutCreateFlagBits; +typedef VkFlags VkPipelineLayoutCreateFlags; +typedef VkFlags VkShaderStageFlags; + +typedef enum VkSamplerCreateFlagBits { + VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001, + VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002, + VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, + VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT = 0x00000004, + VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM = 0x00000010, + VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSamplerCreateFlagBits; +typedef VkFlags VkSamplerCreateFlags; + +typedef enum VkDescriptorPoolCreateFlagBits { + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, + VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002, + VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT = 0x00000004, + VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, + VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT, + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorPoolCreateFlagBits; +typedef VkFlags VkDescriptorPoolCreateFlags; +typedef VkFlags VkDescriptorPoolResetFlags; + +typedef enum VkDescriptorSetLayoutCreateFlagBits { + VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00000010, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0x00000020, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0x00000004, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorSetLayoutCreateFlagBits; +typedef VkFlags VkDescriptorSetLayoutCreateFlags; + +typedef enum VkAttachmentDescriptionFlagBits { + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentDescriptionFlagBits; +typedef VkFlags VkAttachmentDescriptionFlags; + +typedef enum VkDependencyFlagBits { + VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, + VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, + VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, + VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0x00000008, + VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, + VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDependencyFlagBits; +typedef VkFlags VkDependencyFlags; + +typedef enum VkFramebufferCreateFlagBits { + VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001, + VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, + VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFramebufferCreateFlagBits; +typedef VkFlags VkFramebufferCreateFlags; + +typedef enum VkRenderPassCreateFlagBits { + VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002, + VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkRenderPassCreateFlagBits; +typedef VkFlags VkRenderPassCreateFlags; + +typedef enum VkSubpassDescriptionFlagBits { + VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, + VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, + VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004, + VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT = 0x00000010, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000020, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000040, + VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000080, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, + VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassDescriptionFlagBits; +typedef VkFlags VkSubpassDescriptionFlags; + +typedef enum VkCommandPoolCreateFlagBits { + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolCreateFlagBits; +typedef VkFlags VkCommandPoolCreateFlags; + +typedef enum VkCommandPoolResetFlagBits { + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolResetFlagBits; +typedef VkFlags VkCommandPoolResetFlags; + +typedef enum VkCommandBufferUsageFlagBits { + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferUsageFlagBits; +typedef VkFlags VkCommandBufferUsageFlags; + +typedef enum VkQueryControlFlagBits { + VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryControlFlagBits; +typedef VkFlags VkQueryControlFlags; + +typedef enum VkCommandBufferResetFlagBits { + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferResetFlagBits; +typedef VkFlags VkCommandBufferResetFlags; + +typedef enum VkStencilFaceFlagBits { + VK_STENCIL_FACE_FRONT_BIT = 0x00000001, + VK_STENCIL_FACE_BACK_BIT = 0x00000002, + VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, + VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK, + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkStencilFaceFlagBits; +typedef VkFlags VkStencilFaceFlags; +typedef struct VkExtent2D { + uint32_t width; + uint32_t height; +} VkExtent2D; + +typedef struct VkExtent3D { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkExtent3D; + +typedef struct VkOffset2D { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct VkOffset3D { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct VkRect2D { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct VkBaseInStructure { + VkStructureType sType; + const struct VkBaseInStructure* pNext; +} VkBaseInStructure; + +typedef struct VkBaseOutStructure { + VkStructureType sType; + struct VkBaseOutStructure* pNext; +} VkBaseOutStructure; + +typedef struct VkBufferMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct VkDispatchIndirectCommand { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCommand; + +typedef struct VkDrawIndexedIndirectCommand { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCommand; + +typedef struct VkDrawIndirectCommand { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCommand; + +typedef struct VkImageSubresourceRange { + VkImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceRange; + +typedef struct VkImageMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct VkMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} VkMemoryBarrier; + +typedef struct VkPipelineCacheHeaderVersionOne { + uint32_t headerSize; + VkPipelineCacheHeaderVersion headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; +} VkPipelineCacheHeaderVersionOne; + +typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + +typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); +typedef struct VkAllocationCallbacks { + void* pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} VkAllocationCallbacks; + +typedef struct VkApplicationInfo { + VkStructureType sType; + const void* pNext; + const char* pApplicationName; + uint32_t applicationVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef struct VkFormatProperties { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} VkFormatProperties; + +typedef struct VkImageFormatProperties { + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} VkImageFormatProperties; + +typedef struct VkInstanceCreateInfo { + VkStructureType sType; + const void* pNext; + VkInstanceCreateFlags flags; + const VkApplicationInfo* pApplicationInfo; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef struct VkMemoryHeap { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkMemoryType { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct VkPhysicalDeviceFeatures { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSrcBlend; + VkBool32 logicOp; + VkBool32 multiDrawIndirect; + VkBool32 drawIndirectFirstInstance; + VkBool32 depthClamp; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 alphaToOne; + VkBool32 multiViewport; + VkBool32 samplerAnisotropy; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 occlusionQueryPrecise; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexPipelineStoresAndAtomics; + VkBool32 fragmentStoresAndAtomics; + VkBool32 shaderTessellationAndGeometryPointSize; + VkBool32 shaderImageGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageImageReadWithoutFormat; + VkBool32 shaderStorageImageWriteWithoutFormat; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLod; + VkBool32 sparseBinding; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyAliased; + VkBool32 variableMultisampleRate; + VkBool32 inheritedQueries; +} VkPhysicalDeviceFeatures; + +typedef struct VkPhysicalDeviceLimits { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} VkPhysicalDeviceLimits; + +typedef struct VkPhysicalDeviceMemoryProperties { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef struct VkPhysicalDeviceSparseProperties { + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} VkPhysicalDeviceSparseProperties; + +typedef struct VkPhysicalDeviceProperties { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties; + +typedef struct VkQueueFamilyProperties { + VkQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + VkExtent3D minImageTransferGranularity; +} VkQueueFamilyProperties; + +typedef struct VkDeviceQueueCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities; +} VkDeviceQueueCreateInfo; + +typedef struct VkDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const VkDeviceQueueCreateInfo* pQueueCreateInfos; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures* pEnabledFeatures; +} VkDeviceCreateInfo; + +typedef struct VkExtensionProperties { + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct VkLayerProperties { + char layerName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkLayerProperties; + +typedef struct VkSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + const VkPipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + const VkCommandBuffer* pCommandBuffers; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkSubmitInfo; + +typedef struct VkMappedMemoryRange { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct VkMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocateInfo; + +typedef struct VkMemoryRequirements { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct VkSparseMemoryBind { + VkDeviceSize resourceOffset; + VkDeviceSize size; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseMemoryBind; + +typedef struct VkSparseBufferMemoryBindInfo { + VkBuffer buffer; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseBufferMemoryBindInfo; + +typedef struct VkSparseImageOpaqueMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseImageOpaqueMemoryBindInfo; + +typedef struct VkImageSubresource { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t arrayLayer; +} VkImageSubresource; + +typedef struct VkSparseImageMemoryBind { + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseImageMemoryBind; + +typedef struct VkSparseImageMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseImageMemoryBind* pBinds; +} VkSparseImageMemoryBindInfo; + +typedef struct VkBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t bufferBindCount; + const VkSparseBufferMemoryBindInfo* pBufferBinds; + uint32_t imageOpaqueBindCount; + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + uint32_t imageBindCount; + const VkSparseImageMemoryBindInfo* pImageBinds; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkBindSparseInfo; + +typedef struct VkSparseImageFormatProperties { + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} VkSparseImageFormatProperties; + +typedef struct VkSparseImageMemoryRequirements { + VkSparseImageFormatProperties formatProperties; + uint32_t imageMipTailFirstLod; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} VkSparseImageMemoryRequirements; + +typedef struct VkFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct VkSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct VkEventCreateInfo { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct VkQueryPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct VkBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct VkBufferViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct VkImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo; + +typedef struct VkSubresourceLayout { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct VkComponentMapping { + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} VkComponentMapping; + +typedef struct VkImageViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; + +typedef struct VkShaderModuleCreateInfo { + VkStructureType sType; + const void* pNext; + VkShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode; +} VkShaderModuleCreateInfo; + +typedef struct VkPipelineCacheCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCacheCreateFlags flags; + size_t initialDataSize; + const void* pInitialData; +} VkPipelineCacheCreateInfo; + +typedef struct VkSpecializationMapEntry { + uint32_t constantID; + uint32_t offset; + size_t size; +} VkSpecializationMapEntry; + +typedef struct VkSpecializationInfo { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMapEntries; + size_t dataSize; + const void* pData; +} VkSpecializationInfo; + +typedef struct VkPipelineShaderStageCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule module; + const char* pName; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct VkComputePipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct VkVertexInputBindingDescription { + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; +} VkVertexInputBindingDescription; + +typedef struct VkVertexInputAttributeDescription { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription; + +typedef struct VkPipelineVertexInputStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct VkPipelineInputAssemblyStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct VkPipelineTessellationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct VkViewport { + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct VkPipelineViewportStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const VkViewport* pViewports; + uint32_t scissorCount; + const VkRect2D* pScissors; +} VkPipelineViewportStateCreateInfo; + +typedef struct VkPipelineRasterizationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} VkPipelineRasterizationStateCreateInfo; + +typedef struct VkPipelineMultisampleStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + const VkSampleMask* pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct VkStencilOpState { + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; +} VkStencilOpState; + +typedef struct VkPipelineDepthStencilStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct VkPipelineColorBlendAttachmentState { + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct VkPipelineColorBlendStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct VkPipelineDynamicStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + +typedef struct VkGraphicsPipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; + const VkPipelineViewportStateCreateInfo* pViewportState; + const VkPipelineRasterizationStateCreateInfo* pRasterizationState; + const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct VkPushConstantRange { + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; +} VkPushConstantRange; + +typedef struct VkPipelineLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct VkSamplerCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo; + +typedef struct VkCopyDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; +} VkCopyDescriptorSet; + +typedef struct VkDescriptorBufferInfo { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + +typedef struct VkDescriptorImageInfo { + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; + +typedef struct VkDescriptorPoolSize { + VkDescriptorType type; + uint32_t descriptorCount; +} VkDescriptorPoolSize; + +typedef struct VkDescriptorPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const VkDescriptorPoolSize* pPoolSizes; +} VkDescriptorPoolCreateInfo; + +typedef struct VkDescriptorSetAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; +} VkDescriptorSetAllocateInfo; + +typedef struct VkDescriptorSetLayoutBinding { + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct VkDescriptorSetLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const VkDescriptorSetLayoutBinding* pBindings; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct VkWriteDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + const VkDescriptorImageInfo* pImageInfo; + const VkDescriptorBufferInfo* pBufferInfo; + const VkBufferView* pTexelBufferView; +} VkWriteDescriptorSet; + +typedef struct VkAttachmentDescription { + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; + +typedef struct VkAttachmentReference { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct VkFramebufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint32_t attachmentCount; + const VkImageView* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct VkSubpassDescription { + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const VkAttachmentReference* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference* pColorAttachments; + const VkAttachmentReference* pResolveAttachments; + const VkAttachmentReference* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription; + +typedef struct VkSubpassDependency { + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} VkSubpassDependency; + +typedef struct VkRenderPassCreateInfo { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct VkCommandPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo; + +typedef struct VkCommandBufferAllocateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; +} VkCommandBufferAllocateInfo; + +typedef struct VkCommandBufferInheritanceInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo; + +typedef struct VkCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + VkCommandBufferUsageFlags flags; + const VkCommandBufferInheritanceInfo* pInheritanceInfo; +} VkCommandBufferBeginInfo; + +typedef struct VkBufferCopy { + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy; + +typedef struct VkImageSubresourceLayers { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceLayers; + +typedef struct VkBufferImageCopy { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef union VkClearColorValue { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; +} VkClearColorValue; + +typedef struct VkClearDepthStencilValue { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} VkClearValue; + +typedef struct VkClearAttachment { + VkImageAspectFlags aspectMask; + uint32_t colorAttachment; + VkClearValue clearValue; +} VkClearAttachment; + +typedef struct VkClearRect { + VkRect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkClearRect; + +typedef struct VkImageBlit { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit; + +typedef struct VkImageCopy { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkImageResolve { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef struct VkRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + const VkClearValue* pClearValues; +} VkRenderPassBeginInfo; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); +typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); +typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); +typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); +typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); +typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); +typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); +typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); +typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); +typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); +typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); +typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); +typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance); + +VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( + VkInstance instance, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( + VkInstance instance, + const char* pName); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( + VkDevice device, + const char* pName); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( + VkDevice device, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( + VkQueue queue); + +VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( + VkDevice device); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory); + +VKAPI_ATTR void VKAPI_CALL vkFreeMemory( + VkDevice device, + VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( + VkDevice device, + VkDeviceMemory memory); + +VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( + VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFence( + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( + VkDevice device, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore); + +VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent); + +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImage( + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule); + +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler); + +VKAPI_ATTR void VKAPI_CALL vkDestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( + VkCommandBuffer commandBuffer, + const float blendConstants[4]); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); +#endif + + +#define VK_VERSION_1_1 1 +// Vulkan 1.1 version number +#define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0 + +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) +#define VK_MAX_DEVICE_GROUP_SIZE 32U +#define VK_LUID_SIZE 8U +#define VK_QUEUE_FAMILY_EXTERNAL (~1U) + +typedef enum VkPointClippingBehavior { + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkPointClippingBehavior; + +typedef enum VkTessellationDomainOrigin { + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF +} VkTessellationDomainOrigin; + +typedef enum VkSamplerYcbcrModelConversion { + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrModelConversion; + +typedef enum VkSamplerYcbcrRange { + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, + VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, + VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrRange; + +typedef enum VkChromaLocation { + VK_CHROMA_LOCATION_COSITED_EVEN = 0, + VK_CHROMA_LOCATION_MIDPOINT = 1, + VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN, + VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT, + VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF +} VkChromaLocation; + +typedef enum VkDescriptorUpdateTemplateType { + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorUpdateTemplateType; + +typedef enum VkSubgroupFeatureFlagBits { + VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, + VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, + VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, + VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, + VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, + VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, + VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, + VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, + VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, + VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubgroupFeatureFlagBits; +typedef VkFlags VkSubgroupFeatureFlags; + +typedef enum VkPeerMemoryFeatureFlagBits { + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPeerMemoryFeatureFlagBits; +typedef VkFlags VkPeerMemoryFeatureFlags; + +typedef enum VkMemoryAllocateFlagBits { + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004, + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryAllocateFlagBits; +typedef VkFlags VkMemoryAllocateFlags; +typedef VkFlags VkCommandPoolTrimFlags; +typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; + +typedef enum VkExternalMemoryHandleTypeFlagBits { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBits; +typedef VkFlags VkExternalMemoryHandleTypeFlags; + +typedef enum VkExternalMemoryFeatureFlagBits { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBits; +typedef VkFlags VkExternalMemoryFeatureFlags; + +typedef enum VkExternalFenceHandleTypeFlagBits { + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalFenceHandleTypeFlagBits; +typedef VkFlags VkExternalFenceHandleTypeFlags; + +typedef enum VkExternalFenceFeatureFlagBits { + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalFenceFeatureFlagBits; +typedef VkFlags VkExternalFenceFeatureFlags; + +typedef enum VkFenceImportFlagBits { + VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFenceImportFlagBits; +typedef VkFlags VkFenceImportFlags; + +typedef enum VkSemaphoreImportFlagBits { + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreImportFlagBits; +typedef VkFlags VkSemaphoreImportFlags; + +typedef enum VkExternalSemaphoreHandleTypeFlagBits { + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0x00000080, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalSemaphoreHandleTypeFlagBits; +typedef VkFlags VkExternalSemaphoreHandleTypeFlags; + +typedef enum VkExternalSemaphoreFeatureFlagBits { + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalSemaphoreFeatureFlagBits; +typedef VkFlags VkExternalSemaphoreFeatureFlags; +typedef struct VkPhysicalDeviceSubgroupProperties { + VkStructureType sType; + void* pNext; + uint32_t subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} VkPhysicalDeviceSubgroupProperties; + +typedef struct VkBindBufferMemoryInfo { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindBufferMemoryInfo; + +typedef struct VkBindImageMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindImageMemoryInfo; + +typedef struct VkPhysicalDevice16BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeatures; + +typedef struct VkMemoryDedicatedRequirements { + VkStructureType sType; + void* pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirements; + +typedef struct VkMemoryDedicatedAllocateInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkMemoryDedicatedAllocateInfo; + +typedef struct VkMemoryAllocateFlagsInfo { + VkStructureType sType; + const void* pNext; + VkMemoryAllocateFlags flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfo; + +typedef struct VkDeviceGroupRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D* pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfo; + +typedef struct VkDeviceGroupCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; +} VkDeviceGroupCommandBufferBeginInfo; + +typedef struct VkDeviceGroupSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + const uint32_t* pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + const uint32_t* pSignalSemaphoreDeviceIndices; +} VkDeviceGroupSubmitInfo; + +typedef struct VkDeviceGroupBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; +} VkDeviceGroupBindSparseInfo; + +typedef struct VkBindBufferMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindBufferMemoryDeviceGroupInfo; + +typedef struct VkBindImageMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + const VkRect2D* pSplitInstanceBindRegions; +} VkBindImageMemoryDeviceGroupInfo; + +typedef struct VkPhysicalDeviceGroupProperties { + VkStructureType sType; + void* pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupProperties; + +typedef struct VkDeviceGroupDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t physicalDeviceCount; + const VkPhysicalDevice* pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfo; + +typedef struct VkBufferMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferMemoryRequirementsInfo2; + +typedef struct VkImageMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageMemoryRequirementsInfo2; + +typedef struct VkImageSparseMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageSparseMemoryRequirementsInfo2; + +typedef struct VkMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkMemoryRequirements memoryRequirements; +} VkMemoryRequirements2; + +typedef struct VkSparseImageMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkSparseImageMemoryRequirements memoryRequirements; +} VkSparseImageMemoryRequirements2; + +typedef struct VkPhysicalDeviceFeatures2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceFeatures features; +} VkPhysicalDeviceFeatures2; + +typedef struct VkPhysicalDeviceProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceProperties properties; +} VkPhysicalDeviceProperties2; + +typedef struct VkFormatProperties2 { + VkStructureType sType; + void* pNext; + VkFormatProperties formatProperties; +} VkFormatProperties2; + +typedef struct VkImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkImageFormatProperties imageFormatProperties; +} VkImageFormatProperties2; + +typedef struct VkPhysicalDeviceImageFormatInfo2 { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} VkPhysicalDeviceImageFormatInfo2; + +typedef struct VkQueueFamilyProperties2 { + VkStructureType sType; + void* pNext; + VkQueueFamilyProperties queueFamilyProperties; +} VkQueueFamilyProperties2; + +typedef struct VkPhysicalDeviceMemoryProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceMemoryProperties memoryProperties; +} VkPhysicalDeviceMemoryProperties2; + +typedef struct VkSparseImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkSparseImageFormatProperties properties; +} VkSparseImageFormatProperties2; + +typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; +} VkPhysicalDeviceSparseImageFormatInfo2; + +typedef struct VkPhysicalDevicePointClippingProperties { + VkStructureType sType; + void* pNext; + VkPointClippingBehavior pointClippingBehavior; +} VkPhysicalDevicePointClippingProperties; + +typedef struct VkInputAttachmentAspectReference { + uint32_t subpass; + uint32_t inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} VkInputAttachmentAspectReference; + +typedef struct VkRenderPassInputAttachmentAspectCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t aspectReferenceCount; + const VkInputAttachmentAspectReference* pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfo; + +typedef struct VkImageViewUsageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfo; + +typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkTessellationDomainOrigin domainOrigin; +} VkPipelineTessellationDomainOriginStateCreateInfo; + +typedef struct VkRenderPassMultiviewCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + const int32_t* pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks; +} VkRenderPassMultiviewCreateInfo; + +typedef struct VkPhysicalDeviceMultiviewFeatures { + VkStructureType sType; + void* pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeatures; + +typedef struct VkPhysicalDeviceMultiviewProperties { + VkStructureType sType; + void* pNext; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewProperties; + +typedef struct VkPhysicalDeviceVariablePointersFeatures { + VkStructureType sType; + void* pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointersFeatures; + +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 protectedMemory; +} VkPhysicalDeviceProtectedMemoryFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryProperties { + VkStructureType sType; + void* pNext; + VkBool32 protectedNoFault; +} VkPhysicalDeviceProtectedMemoryProperties; + +typedef struct VkDeviceQueueInfo2 { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; +} VkDeviceQueueInfo2; + +typedef struct VkProtectedSubmitInfo { + VkStructureType sType; + const void* pNext; + VkBool32 protectedSubmit; +} VkProtectedSubmitInfo; + +typedef struct VkSamplerYcbcrConversionCreateInfo { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} VkSamplerYcbcrConversionCreateInfo; + +typedef struct VkSamplerYcbcrConversionInfo { + VkStructureType sType; + const void* pNext; + VkSamplerYcbcrConversion conversion; +} VkSamplerYcbcrConversionInfo; + +typedef struct VkBindImagePlaneMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkBindImagePlaneMemoryInfo; + +typedef struct VkImagePlaneMemoryRequirementsInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkImagePlaneMemoryRequirementsInfo; + +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { + VkStructureType sType; + void* pNext; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeatures; + +typedef struct VkSamplerYcbcrConversionImageFormatProperties { + VkStructureType sType; + void* pNext; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatProperties; + +typedef struct VkDescriptorUpdateTemplateEntry { + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + size_t offset; + size_t stride; +} VkDescriptorUpdateTemplateEntry; + +typedef struct VkDescriptorUpdateTemplateCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorUpdateTemplateCreateFlags flags; + uint32_t descriptorUpdateEntryCount; + const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateType templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint32_t set; +} VkDescriptorUpdateTemplateCreateInfo; + +typedef struct VkExternalMemoryProperties { + VkExternalMemoryFeatureFlags externalMemoryFeatures; + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlags compatibleHandleTypes; +} VkExternalMemoryProperties; + +typedef struct VkPhysicalDeviceExternalImageFormatInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalImageFormatInfo; + +typedef struct VkExternalImageFormatProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalImageFormatProperties; + +typedef struct VkPhysicalDeviceExternalBufferInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalBufferInfo; + +typedef struct VkExternalBufferProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalBufferProperties; + +typedef struct VkPhysicalDeviceIDProperties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDProperties; + +typedef struct VkExternalMemoryImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryImageCreateInfo; + +typedef struct VkExternalMemoryBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryBufferCreateInfo; + +typedef struct VkExportMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExportMemoryAllocateInfo; + +typedef struct VkPhysicalDeviceExternalFenceInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalFenceInfo; + +typedef struct VkExternalFenceProperties { + VkStructureType sType; + void* pNext; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} VkExternalFenceProperties; + +typedef struct VkExportFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlags handleTypes; +} VkExportFenceCreateInfo; + +typedef struct VkExportSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} VkExportSemaphoreCreateInfo; + +typedef struct VkPhysicalDeviceExternalSemaphoreInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalSemaphoreInfo; + +typedef struct VkExternalSemaphoreProperties { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} VkExternalSemaphoreProperties; + +typedef struct VkPhysicalDeviceMaintenance3Properties { + VkStructureType sType; + void* pNext; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceMaintenance3Properties; + +typedef struct VkDescriptorSetLayoutSupport { + VkStructureType sType; + void* pNext; + VkBool32 supported; +} VkDescriptorSetLayoutSupport; + +typedef struct VkPhysicalDeviceShaderDrawParametersFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceShaderDrawParametersFeatures; + +typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( + uint32_t* pApiVersion); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( + VkDevice device, + const VkDeviceQueueInfo2* pQueueInfo, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); +#endif + + +#define VK_VERSION_1_2 1 +// Vulkan 1.2 version number +#define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0 + +#define VK_MAX_DRIVER_NAME_SIZE 256U +#define VK_MAX_DRIVER_INFO_SIZE 256U + +typedef enum VkDriverId { + VK_DRIVER_ID_AMD_PROPRIETARY = 1, + VK_DRIVER_ID_AMD_OPEN_SOURCE = 2, + VK_DRIVER_ID_MESA_RADV = 3, + VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4, + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5, + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6, + VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7, + VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8, + VK_DRIVER_ID_ARM_PROPRIETARY = 9, + VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10, + VK_DRIVER_ID_GGP_PROPRIETARY = 11, + VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12, + VK_DRIVER_ID_MESA_LLVMPIPE = 13, + VK_DRIVER_ID_MOLTENVK = 14, + VK_DRIVER_ID_COREAVI_PROPRIETARY = 15, + VK_DRIVER_ID_JUICE_PROPRIETARY = 16, + VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17, + VK_DRIVER_ID_MESA_TURNIP = 18, + VK_DRIVER_ID_MESA_V3DV = 19, + VK_DRIVER_ID_MESA_PANVK = 20, + VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21, + VK_DRIVER_ID_MESA_VENUS = 22, + VK_DRIVER_ID_MESA_DOZEN = 23, + VK_DRIVER_ID_MESA_NVK = 24, + VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25, + VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY, + VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE, + VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV, + VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY, + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS, + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA, + VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY, + VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY, + VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY, + VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER, + VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY, + VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY, + VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF +} VkDriverId; + +typedef enum VkShaderFloatControlsIndependence { + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF +} VkShaderFloatControlsIndependence; + +typedef enum VkSamplerReductionMode { + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, + VK_SAMPLER_REDUCTION_MODE_MIN = 1, + VK_SAMPLER_REDUCTION_MODE_MAX = 2, + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, + VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN, + VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX, + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerReductionMode; + +typedef enum VkSemaphoreType { + VK_SEMAPHORE_TYPE_BINARY = 0, + VK_SEMAPHORE_TYPE_TIMELINE = 1, + VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY, + VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE, + VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreType; + +typedef enum VkResolveModeFlagBits { + VK_RESOLVE_MODE_NONE = 0, + VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001, + VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002, + VK_RESOLVE_MODE_MIN_BIT = 0x00000004, + VK_RESOLVE_MODE_MAX_BIT = 0x00000008, + VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE, + VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, + VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT, + VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT, + VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT, + VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkResolveModeFlagBits; +typedef VkFlags VkResolveModeFlags; + +typedef enum VkDescriptorBindingFlagBits { + VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001, + VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002, + VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004, + VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008, + VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, + VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, + VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, + VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, + VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorBindingFlagBits; +typedef VkFlags VkDescriptorBindingFlags; + +typedef enum VkSemaphoreWaitFlagBits { + VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001, + VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT, + VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreWaitFlagBits; +typedef VkFlags VkSemaphoreWaitFlags; +typedef struct VkPhysicalDeviceVulkan11Features { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; + VkBool32 protectedMemory; + VkBool32 samplerYcbcrConversion; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceVulkan11Features; + +typedef struct VkPhysicalDeviceVulkan11Properties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; + uint32_t subgroupSize; + VkShaderStageFlags subgroupSupportedStages; + VkSubgroupFeatureFlags subgroupSupportedOperations; + VkBool32 subgroupQuadOperationsInAllStages; + VkPointClippingBehavior pointClippingBehavior; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; + VkBool32 protectedNoFault; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceVulkan11Properties; + +typedef struct VkPhysicalDeviceVulkan12Features { + VkStructureType sType; + void* pNext; + VkBool32 samplerMirrorClampToEdge; + VkBool32 drawIndirectCount; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; + VkBool32 descriptorIndexing; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; + VkBool32 samplerFilterMinmax; + VkBool32 scalarBlockLayout; + VkBool32 imagelessFramebuffer; + VkBool32 uniformBufferStandardLayout; + VkBool32 shaderSubgroupExtendedTypes; + VkBool32 separateDepthStencilLayouts; + VkBool32 hostQueryReset; + VkBool32 timelineSemaphore; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; + VkBool32 shaderOutputViewportIndex; + VkBool32 shaderOutputLayer; + VkBool32 subgroupBroadcastDynamicId; +} VkPhysicalDeviceVulkan12Features; + +typedef struct VkConformanceVersion { + uint8_t major; + uint8_t minor; + uint8_t subminor; + uint8_t patch; +} VkConformanceVersion; + +typedef struct VkPhysicalDeviceVulkan12Properties { + VkStructureType sType; + void* pNext; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; + uint64_t maxTimelineSemaphoreValueDifference; + VkSampleCountFlags framebufferIntegerColorSampleCounts; +} VkPhysicalDeviceVulkan12Properties; + +typedef struct VkImageFormatListCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkImageFormatListCreateInfo; + +typedef struct VkAttachmentDescription2 { + VkStructureType sType; + const void* pNext; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription2; + +typedef struct VkAttachmentReference2 { + VkStructureType sType; + const void* pNext; + uint32_t attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} VkAttachmentReference2; + +typedef struct VkSubpassDescription2 { + VkStructureType sType; + const void* pNext; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + const VkAttachmentReference2* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference2* pColorAttachments; + const VkAttachmentReference2* pResolveAttachments; + const VkAttachmentReference2* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription2; + +typedef struct VkSubpassDependency2 { + VkStructureType sType; + const void* pNext; + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int32_t viewOffset; +} VkSubpassDependency2; + +typedef struct VkRenderPassCreateInfo2 { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription2* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription2* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency2* pDependencies; + uint32_t correlatedViewMaskCount; + const uint32_t* pCorrelatedViewMasks; +} VkRenderPassCreateInfo2; + +typedef struct VkSubpassBeginInfo { + VkStructureType sType; + const void* pNext; + VkSubpassContents contents; +} VkSubpassBeginInfo; + +typedef struct VkSubpassEndInfo { + VkStructureType sType; + const void* pNext; +} VkSubpassEndInfo; + +typedef struct VkPhysicalDevice8BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; +} VkPhysicalDevice8BitStorageFeatures; + +typedef struct VkPhysicalDeviceDriverProperties { + VkStructureType sType; + void* pNext; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; +} VkPhysicalDeviceDriverProperties; + +typedef struct VkPhysicalDeviceShaderAtomicInt64Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; +} VkPhysicalDeviceShaderAtomicInt64Features; + +typedef struct VkPhysicalDeviceShaderFloat16Int8Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; +} VkPhysicalDeviceShaderFloat16Int8Features; + +typedef struct VkPhysicalDeviceFloatControlsProperties { + VkStructureType sType; + void* pNext; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; +} VkPhysicalDeviceFloatControlsProperties; + +typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t bindingCount; + const VkDescriptorBindingFlags* pBindingFlags; +} VkDescriptorSetLayoutBindingFlagsCreateInfo; + +typedef struct VkPhysicalDeviceDescriptorIndexingFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; +} VkPhysicalDeviceDescriptorIndexingFeatures; + +typedef struct VkPhysicalDeviceDescriptorIndexingProperties { + VkStructureType sType; + void* pNext; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; +} VkPhysicalDeviceDescriptorIndexingProperties; + +typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSetCount; + const uint32_t* pDescriptorCounts; +} VkDescriptorSetVariableDescriptorCountAllocateInfo; + +typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport { + VkStructureType sType; + void* pNext; + uint32_t maxVariableDescriptorCount; +} VkDescriptorSetVariableDescriptorCountLayoutSupport; + +typedef struct VkSubpassDescriptionDepthStencilResolve { + VkStructureType sType; + const void* pNext; + VkResolveModeFlagBits depthResolveMode; + VkResolveModeFlagBits stencilResolveMode; + const VkAttachmentReference2* pDepthStencilResolveAttachment; +} VkSubpassDescriptionDepthStencilResolve; + +typedef struct VkPhysicalDeviceDepthStencilResolveProperties { + VkStructureType sType; + void* pNext; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; +} VkPhysicalDeviceDepthStencilResolveProperties; + +typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures { + VkStructureType sType; + void* pNext; + VkBool32 scalarBlockLayout; +} VkPhysicalDeviceScalarBlockLayoutFeatures; + +typedef struct VkImageStencilUsageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags stencilUsage; +} VkImageStencilUsageCreateInfo; + +typedef struct VkSamplerReductionModeCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerReductionMode reductionMode; +} VkSamplerReductionModeCreateInfo; + +typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties { + VkStructureType sType; + void* pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxProperties; + +typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures { + VkStructureType sType; + void* pNext; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; +} VkPhysicalDeviceVulkanMemoryModelFeatures; + +typedef struct VkPhysicalDeviceImagelessFramebufferFeatures { + VkStructureType sType; + void* pNext; + VkBool32 imagelessFramebuffer; +} VkPhysicalDeviceImagelessFramebufferFeatures; + +typedef struct VkFramebufferAttachmentImageInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageUsageFlags usage; + uint32_t width; + uint32_t height; + uint32_t layerCount; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkFramebufferAttachmentImageInfo; + +typedef struct VkFramebufferAttachmentsCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t attachmentImageInfoCount; + const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos; +} VkFramebufferAttachmentsCreateInfo; + +typedef struct VkRenderPassAttachmentBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkImageView* pAttachments; +} VkRenderPassAttachmentBeginInfo; + +typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures { + VkStructureType sType; + void* pNext; + VkBool32 uniformBufferStandardLayout; +} VkPhysicalDeviceUniformBufferStandardLayoutFeatures; + +typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupExtendedTypes; +} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; + +typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { + VkStructureType sType; + void* pNext; + VkBool32 separateDepthStencilLayouts; +} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; + +typedef struct VkAttachmentReferenceStencilLayout { + VkStructureType sType; + void* pNext; + VkImageLayout stencilLayout; +} VkAttachmentReferenceStencilLayout; + +typedef struct VkAttachmentDescriptionStencilLayout { + VkStructureType sType; + void* pNext; + VkImageLayout stencilInitialLayout; + VkImageLayout stencilFinalLayout; +} VkAttachmentDescriptionStencilLayout; + +typedef struct VkPhysicalDeviceHostQueryResetFeatures { + VkStructureType sType; + void* pNext; + VkBool32 hostQueryReset; +} VkPhysicalDeviceHostQueryResetFeatures; + +typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures { + VkStructureType sType; + void* pNext; + VkBool32 timelineSemaphore; +} VkPhysicalDeviceTimelineSemaphoreFeatures; + +typedef struct VkPhysicalDeviceTimelineSemaphoreProperties { + VkStructureType sType; + void* pNext; + uint64_t maxTimelineSemaphoreValueDifference; +} VkPhysicalDeviceTimelineSemaphoreProperties; + +typedef struct VkSemaphoreTypeCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreType semaphoreType; + uint64_t initialValue; +} VkSemaphoreTypeCreateInfo; + +typedef struct VkTimelineSemaphoreSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValueCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValueCount; + const uint64_t* pSignalSemaphoreValues; +} VkTimelineSemaphoreSubmitInfo; + +typedef struct VkSemaphoreWaitInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreWaitFlags flags; + uint32_t semaphoreCount; + const VkSemaphore* pSemaphores; + const uint64_t* pValues; +} VkSemaphoreWaitInfo; + +typedef struct VkSemaphoreSignalInfo { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + uint64_t value; +} VkSemaphoreSignalInfo; + +typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeatures; + +typedef struct VkBufferDeviceAddressInfo { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferDeviceAddressInfo; + +typedef struct VkBufferOpaqueCaptureAddressCreateInfo { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkBufferOpaqueCaptureAddressCreateInfo; + +typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkMemoryOpaqueCaptureAddressAllocateInfo; + +typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkDeviceMemoryOpaqueCaptureAddressInfo; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo); + +VKAPI_ATTR void VKAPI_CALL vkResetQueryPool( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo); + +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +#endif + + +#define VK_VERSION_1_3 1 +// Vulkan 1.3 version number +#define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0)// Patch version should always be set to 0 + +typedef uint64_t VkFlags64; +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlot) + +typedef enum VkPipelineCreationFeedbackFlagBits { + VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0x00000001, + VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0x00000002, + VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0x00000004, + VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, + VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, + VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT, + VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCreationFeedbackFlagBits; +typedef VkFlags VkPipelineCreationFeedbackFlags; + +typedef enum VkToolPurposeFlagBits { + VK_TOOL_PURPOSE_VALIDATION_BIT = 0x00000001, + VK_TOOL_PURPOSE_PROFILING_BIT = 0x00000002, + VK_TOOL_PURPOSE_TRACING_BIT = 0x00000004, + VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT = 0x00000008, + VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT = 0x00000010, + VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020, + VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040, + VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = VK_TOOL_PURPOSE_VALIDATION_BIT, + VK_TOOL_PURPOSE_PROFILING_BIT_EXT = VK_TOOL_PURPOSE_PROFILING_BIT, + VK_TOOL_PURPOSE_TRACING_BIT_EXT = VK_TOOL_PURPOSE_TRACING_BIT, + VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, + VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT, + VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkToolPurposeFlagBits; +typedef VkFlags VkToolPurposeFlags; +typedef VkFlags VkPrivateDataSlotCreateFlags; +typedef VkFlags64 VkPipelineStageFlags2; + +// Flag bits for VkPipelineStageFlagBits2 +typedef VkFlags64 VkPipelineStageFlagBits2; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE = 0ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 0x00000001ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 0x00000002ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 0x00000004ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 0x00000008ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 0x00000040ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 0x00000080ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 0x00000100ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 0x00000200ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 0x00000800ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 0x00002000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT = 0x00004000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 0x00008000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 0x00010000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT = 0x100000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT = 0x200000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT = 0x400000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT = 0x800000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 0x1000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 0x2000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL; +#ifdef VK_ENABLE_BETA_EXTENSIONS +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL; +#endif +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 0x00080000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT = 0x00100000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR = 0x10000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 0x40000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0x20000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0x20000000ULL; + +typedef VkFlags64 VkAccessFlags2; + +// Flag bits for VkAccessFlagBits2 +typedef VkFlags64 VkAccessFlagBits2; +static const VkAccessFlagBits2 VK_ACCESS_2_NONE = 0ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_NONE_KHR = 0ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 0x00000001ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT = 0x00000002ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT = 0x00000008ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 0x00000010ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT = 0x00000020ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT = 0x00000040ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 0x00000080ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT = 0x00000800ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT = 0x00001000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT = 0x00002000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT = 0x00004000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT = 0x00008000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT = 0x00010000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 0x100000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 0x200000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x400000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL; +#ifdef VK_ENABLE_BETA_EXTENSIONS +static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL; +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS +static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL; +#endif +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT = 0x20000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 0x10000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0x100000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 0x200000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0x40000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0x80000000000ULL; + + +typedef enum VkSubmitFlagBits { + VK_SUBMIT_PROTECTED_BIT = 0x00000001, + VK_SUBMIT_PROTECTED_BIT_KHR = VK_SUBMIT_PROTECTED_BIT, + VK_SUBMIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubmitFlagBits; +typedef VkFlags VkSubmitFlags; + +typedef enum VkRenderingFlagBits { + VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0x00000001, + VK_RENDERING_SUSPENDING_BIT = 0x00000002, + VK_RENDERING_RESUMING_BIT = 0x00000004, + VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008, + VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, + VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT, + VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT, + VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkRenderingFlagBits; +typedef VkFlags VkRenderingFlags; +typedef VkFlags64 VkFormatFeatureFlags2; + +// Flag bits for VkFormatFeatureFlagBits2 +typedef VkFlags64 VkFormatFeatureFlagBits2; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 0x00000001ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 0x00000002ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 0x00000010ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000010ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 0x00000020ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 0x00000040ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 0x00000040ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 0x00000080ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000080ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 0x00000100ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000200ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 0x00000400ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 0x00000400ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 0x00000800ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 0x00000800ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 0x00001000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 0x00002000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 0x00004000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 0x00004000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 0x00008000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 0x00008000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT = 0x00400000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 0x00400000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 0x00800000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 0x80000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 0x80000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 0x100000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 0x100000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 0x200000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL; +#ifdef VK_ENABLE_BETA_EXTENSIONS +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000ULL; +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL; +#endif +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0x400000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0x800000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 0x1000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 0x2000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0x10000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ULL; + +typedef struct VkPhysicalDeviceVulkan13Features { + VkStructureType sType; + void* pNext; + VkBool32 robustImageAccess; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; + VkBool32 pipelineCreationCacheControl; + VkBool32 privateData; + VkBool32 shaderDemoteToHelperInvocation; + VkBool32 shaderTerminateInvocation; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; + VkBool32 synchronization2; + VkBool32 textureCompressionASTC_HDR; + VkBool32 shaderZeroInitializeWorkgroupMemory; + VkBool32 dynamicRendering; + VkBool32 shaderIntegerDotProduct; + VkBool32 maintenance4; +} VkPhysicalDeviceVulkan13Features; + +typedef struct VkPhysicalDeviceVulkan13Properties { + VkStructureType sType; + void* pNext; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + uint32_t maxInlineUniformTotalSize; + VkBool32 integerDotProduct8BitUnsignedAccelerated; + VkBool32 integerDotProduct8BitSignedAccelerated; + VkBool32 integerDotProduct8BitMixedSignednessAccelerated; + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProduct16BitUnsignedAccelerated; + VkBool32 integerDotProduct16BitSignedAccelerated; + VkBool32 integerDotProduct16BitMixedSignednessAccelerated; + VkBool32 integerDotProduct32BitUnsignedAccelerated; + VkBool32 integerDotProduct32BitSignedAccelerated; + VkBool32 integerDotProduct32BitMixedSignednessAccelerated; + VkBool32 integerDotProduct64BitUnsignedAccelerated; + VkBool32 integerDotProduct64BitSignedAccelerated; + VkBool32 integerDotProduct64BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize maxBufferSize; +} VkPhysicalDeviceVulkan13Properties; + +typedef struct VkPipelineCreationFeedback { + VkPipelineCreationFeedbackFlags flags; + uint64_t duration; +} VkPipelineCreationFeedback; + +typedef struct VkPipelineCreationFeedbackCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreationFeedback* pPipelineCreationFeedback; + uint32_t pipelineStageCreationFeedbackCount; + VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks; +} VkPipelineCreationFeedbackCreateInfo; + +typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderTerminateInvocation; +} VkPhysicalDeviceShaderTerminateInvocationFeatures; + +typedef struct VkPhysicalDeviceToolProperties { + VkStructureType sType; + void* pNext; + char name[VK_MAX_EXTENSION_NAME_SIZE]; + char version[VK_MAX_EXTENSION_NAME_SIZE]; + VkToolPurposeFlags purposes; + char description[VK_MAX_DESCRIPTION_SIZE]; + char layer[VK_MAX_EXTENSION_NAME_SIZE]; +} VkPhysicalDeviceToolProperties; + +typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDemoteToHelperInvocation; +} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures; + +typedef struct VkPhysicalDevicePrivateDataFeatures { + VkStructureType sType; + void* pNext; + VkBool32 privateData; +} VkPhysicalDevicePrivateDataFeatures; + +typedef struct VkDevicePrivateDataCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t privateDataSlotRequestCount; +} VkDevicePrivateDataCreateInfo; + +typedef struct VkPrivateDataSlotCreateInfo { + VkStructureType sType; + const void* pNext; + VkPrivateDataSlotCreateFlags flags; +} VkPrivateDataSlotCreateInfo; + +typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures { + VkStructureType sType; + void* pNext; + VkBool32 pipelineCreationCacheControl; +} VkPhysicalDevicePipelineCreationCacheControlFeatures; + +typedef struct VkMemoryBarrier2 { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; +} VkMemoryBarrier2; + +typedef struct VkBufferMemoryBarrier2 { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier2; + +typedef struct VkImageMemoryBarrier2 { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier2; + +typedef struct VkDependencyInfo { + VkStructureType sType; + const void* pNext; + VkDependencyFlags dependencyFlags; + uint32_t memoryBarrierCount; + const VkMemoryBarrier2* pMemoryBarriers; + uint32_t bufferMemoryBarrierCount; + const VkBufferMemoryBarrier2* pBufferMemoryBarriers; + uint32_t imageMemoryBarrierCount; + const VkImageMemoryBarrier2* pImageMemoryBarriers; +} VkDependencyInfo; + +typedef struct VkSemaphoreSubmitInfo { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + uint64_t value; + VkPipelineStageFlags2 stageMask; + uint32_t deviceIndex; +} VkSemaphoreSubmitInfo; + +typedef struct VkCommandBufferSubmitInfo { + VkStructureType sType; + const void* pNext; + VkCommandBuffer commandBuffer; + uint32_t deviceMask; +} VkCommandBufferSubmitInfo; + +typedef struct VkSubmitInfo2 { + VkStructureType sType; + const void* pNext; + VkSubmitFlags flags; + uint32_t waitSemaphoreInfoCount; + const VkSemaphoreSubmitInfo* pWaitSemaphoreInfos; + uint32_t commandBufferInfoCount; + const VkCommandBufferSubmitInfo* pCommandBufferInfos; + uint32_t signalSemaphoreInfoCount; + const VkSemaphoreSubmitInfo* pSignalSemaphoreInfos; +} VkSubmitInfo2; + +typedef struct VkPhysicalDeviceSynchronization2Features { + VkStructureType sType; + void* pNext; + VkBool32 synchronization2; +} VkPhysicalDeviceSynchronization2Features; + +typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderZeroInitializeWorkgroupMemory; +} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + +typedef struct VkPhysicalDeviceImageRobustnessFeatures { + VkStructureType sType; + void* pNext; + VkBool32 robustImageAccess; +} VkPhysicalDeviceImageRobustnessFeatures; + +typedef struct VkBufferCopy2 { + VkStructureType sType; + const void* pNext; + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy2; + +typedef struct VkCopyBufferInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer srcBuffer; + VkBuffer dstBuffer; + uint32_t regionCount; + const VkBufferCopy2* pRegions; +} VkCopyBufferInfo2; + +typedef struct VkImageCopy2 { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy2; + +typedef struct VkCopyImageInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageCopy2* pRegions; +} VkCopyImageInfo2; + +typedef struct VkBufferImageCopy2 { + VkStructureType sType; + const void* pNext; + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy2; + +typedef struct VkCopyBufferToImageInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer srcBuffer; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkBufferImageCopy2* pRegions; +} VkCopyBufferToImageInfo2; + +typedef struct VkCopyImageToBufferInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkBuffer dstBuffer; + uint32_t regionCount; + const VkBufferImageCopy2* pRegions; +} VkCopyImageToBufferInfo2; + +typedef struct VkImageBlit2 { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit2; + +typedef struct VkBlitImageInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageBlit2* pRegions; + VkFilter filter; +} VkBlitImageInfo2; + +typedef struct VkImageResolve2 { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve2; + +typedef struct VkResolveImageInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageResolve2* pRegions; +} VkResolveImageInfo2; + +typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures { + VkStructureType sType; + void* pNext; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; +} VkPhysicalDeviceSubgroupSizeControlFeatures; + +typedef struct VkPhysicalDeviceSubgroupSizeControlProperties { + VkStructureType sType; + void* pNext; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; +} VkPhysicalDeviceSubgroupSizeControlProperties; + +typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo { + VkStructureType sType; + void* pNext; + uint32_t requiredSubgroupSize; +} VkPipelineShaderStageRequiredSubgroupSizeCreateInfo; + +typedef struct VkPhysicalDeviceInlineUniformBlockFeatures { + VkStructureType sType; + void* pNext; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; +} VkPhysicalDeviceInlineUniformBlockFeatures; + +typedef struct VkPhysicalDeviceInlineUniformBlockProperties { + VkStructureType sType; + void* pNext; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; +} VkPhysicalDeviceInlineUniformBlockProperties; + +typedef struct VkWriteDescriptorSetInlineUniformBlock { + VkStructureType sType; + const void* pNext; + uint32_t dataSize; + const void* pData; +} VkWriteDescriptorSetInlineUniformBlock; + +typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t maxInlineUniformBlockBindings; +} VkDescriptorPoolInlineUniformBlockCreateInfo; + +typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures { + VkStructureType sType; + void* pNext; + VkBool32 textureCompressionASTC_HDR; +} VkPhysicalDeviceTextureCompressionASTCHDRFeatures; + +typedef struct VkRenderingAttachmentInfo { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkImageLayout imageLayout; + VkResolveModeFlagBits resolveMode; + VkImageView resolveImageView; + VkImageLayout resolveImageLayout; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkClearValue clearValue; +} VkRenderingAttachmentInfo; + +typedef struct VkRenderingInfo { + VkStructureType sType; + const void* pNext; + VkRenderingFlags flags; + VkRect2D renderArea; + uint32_t layerCount; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkRenderingAttachmentInfo* pColorAttachments; + const VkRenderingAttachmentInfo* pDepthAttachment; + const VkRenderingAttachmentInfo* pStencilAttachment; +} VkRenderingInfo; + +typedef struct VkPipelineRenderingCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; +} VkPipelineRenderingCreateInfo; + +typedef struct VkPhysicalDeviceDynamicRenderingFeatures { + VkStructureType sType; + void* pNext; + VkBool32 dynamicRendering; +} VkPhysicalDeviceDynamicRenderingFeatures; + +typedef struct VkCommandBufferInheritanceRenderingInfo { + VkStructureType sType; + const void* pNext; + VkRenderingFlags flags; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; + VkSampleCountFlagBits rasterizationSamples; +} VkCommandBufferInheritanceRenderingInfo; + +typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderIntegerDotProduct; +} VkPhysicalDeviceShaderIntegerDotProductFeatures; + +typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties { + VkStructureType sType; + void* pNext; + VkBool32 integerDotProduct8BitUnsignedAccelerated; + VkBool32 integerDotProduct8BitSignedAccelerated; + VkBool32 integerDotProduct8BitMixedSignednessAccelerated; + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProduct16BitUnsignedAccelerated; + VkBool32 integerDotProduct16BitSignedAccelerated; + VkBool32 integerDotProduct16BitMixedSignednessAccelerated; + VkBool32 integerDotProduct32BitUnsignedAccelerated; + VkBool32 integerDotProduct32BitSignedAccelerated; + VkBool32 integerDotProduct32BitMixedSignednessAccelerated; + VkBool32 integerDotProduct64BitUnsignedAccelerated; + VkBool32 integerDotProduct64BitSignedAccelerated; + VkBool32 integerDotProduct64BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; +} VkPhysicalDeviceShaderIntegerDotProductProperties; + +typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties { + VkStructureType sType; + void* pNext; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; +} VkPhysicalDeviceTexelBufferAlignmentProperties; + +typedef struct VkFormatProperties3 { + VkStructureType sType; + void* pNext; + VkFormatFeatureFlags2 linearTilingFeatures; + VkFormatFeatureFlags2 optimalTilingFeatures; + VkFormatFeatureFlags2 bufferFeatures; +} VkFormatProperties3; + +typedef struct VkPhysicalDeviceMaintenance4Features { + VkStructureType sType; + void* pNext; + VkBool32 maintenance4; +} VkPhysicalDeviceMaintenance4Features; + +typedef struct VkPhysicalDeviceMaintenance4Properties { + VkStructureType sType; + void* pNext; + VkDeviceSize maxBufferSize; +} VkPhysicalDeviceMaintenance4Properties; + +typedef struct VkDeviceBufferMemoryRequirements { + VkStructureType sType; + const void* pNext; + const VkBufferCreateInfo* pCreateInfo; +} VkDeviceBufferMemoryRequirements; + +typedef struct VkDeviceImageMemoryRequirements { + VkStructureType sType; + const void* pNext; + const VkImageCreateInfo* pCreateInfo; + VkImageAspectFlagBits planeAspect; +} VkDeviceImageMemoryRequirements; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +typedef void (VKAPI_PTR *PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCount)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCount)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlot( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlot( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data); + +VKAPI_ATTR void VKAPI_CALL vkGetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRendering( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCullMode( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFace( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopology( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCount( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCount( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOp( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOp( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnable( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnable( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +#endif + + +#define VK_KHR_surface 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) +#define VK_KHR_SURFACE_SPEC_VERSION 25 +#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" + +typedef enum VkPresentModeKHR { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, + VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, + VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentModeKHR; + +typedef enum VkColorSpaceKHR { + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, + VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, + VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003, + VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, + VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, + VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, + VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, + VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, + VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, + VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, + VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, + VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, + VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, + VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, + VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000, + VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, + VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkColorSpaceKHR; + +typedef enum VkSurfaceTransformFlagBitsKHR { + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, + VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSurfaceTransformFlagBitsKHR; + +typedef enum VkCompositeAlphaFlagBitsKHR { + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, + VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkCompositeAlphaFlagBitsKHR; +typedef VkFlags VkCompositeAlphaFlagsKHR; +typedef VkFlags VkSurfaceTransformFlagsKHR; +typedef struct VkSurfaceCapabilitiesKHR { + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; +} VkSurfaceCapabilitiesKHR; + +typedef struct VkSurfaceFormatKHR { + VkFormat format; + VkColorSpaceKHR colorSpace; +} VkSurfaceFormatKHR; + +typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); +#endif + + +#define VK_KHR_swapchain 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) +#define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 +#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" + +typedef enum VkSwapchainCreateFlagBitsKHR { + VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, + VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, + VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, + VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = 0x00000008, + VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSwapchainCreateFlagBitsKHR; +typedef VkFlags VkSwapchainCreateFlagsKHR; + +typedef enum VkDeviceGroupPresentModeFlagBitsKHR { + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, + VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, + VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, + VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDeviceGroupPresentModeFlagBitsKHR; +typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; +typedef struct VkSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR oldSwapchain; +} VkSwapchainCreateInfoKHR; + +typedef struct VkPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t swapchainCount; + const VkSwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + VkResult* pResults; +} VkPresentInfoKHR; + +typedef struct VkImageSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; +} VkImageSwapchainCreateInfoKHR; + +typedef struct VkBindImageMemorySwapchainInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHR; + +typedef struct VkAcquireNextImageInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint64_t timeout; + VkSemaphore semaphore; + VkFence fence; + uint32_t deviceMask; +} VkAcquireNextImageInfoKHR; + +typedef struct VkDeviceGroupPresentCapabilitiesKHR { + VkStructureType sType; + void* pNext; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupPresentCapabilitiesKHR; + +typedef struct VkDeviceGroupPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks; + VkDeviceGroupPresentModeFlagBitsKHR mode; +} VkDeviceGroupPresentInfoKHR; + +typedef struct VkDeviceGroupSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupSwapchainCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); +typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain); + +VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( + VkDevice device, + const VkAcquireNextImageInfoKHR* pAcquireInfo, + uint32_t* pImageIndex); +#endif + + +#define VK_KHR_display 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) +#define VK_KHR_DISPLAY_SPEC_VERSION 23 +#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" +typedef VkFlags VkDisplayModeCreateFlagsKHR; + +typedef enum VkDisplayPlaneAlphaFlagBitsKHR { + VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, + VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDisplayPlaneAlphaFlagBitsKHR; +typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; +typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; +typedef struct VkDisplayModeParametersKHR { + VkExtent2D visibleRegion; + uint32_t refreshRate; +} VkDisplayModeParametersKHR; + +typedef struct VkDisplayModeCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeCreateFlagsKHR flags; + VkDisplayModeParametersKHR parameters; +} VkDisplayModeCreateInfoKHR; + +typedef struct VkDisplayModePropertiesKHR { + VkDisplayModeKHR displayMode; + VkDisplayModeParametersKHR parameters; +} VkDisplayModePropertiesKHR; + +typedef struct VkDisplayPlaneCapabilitiesKHR { + VkDisplayPlaneAlphaFlagsKHR supportedAlpha; + VkOffset2D minSrcPosition; + VkOffset2D maxSrcPosition; + VkExtent2D minSrcExtent; + VkExtent2D maxSrcExtent; + VkOffset2D minDstPosition; + VkOffset2D maxDstPosition; + VkExtent2D minDstExtent; + VkExtent2D maxDstExtent; +} VkDisplayPlaneCapabilitiesKHR; + +typedef struct VkDisplayPlanePropertiesKHR { + VkDisplayKHR currentDisplay; + uint32_t currentStackIndex; +} VkDisplayPlanePropertiesKHR; + +typedef struct VkDisplayPropertiesKHR { + VkDisplayKHR display; + const char* displayName; + VkExtent2D physicalDimensions; + VkExtent2D physicalResolution; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkBool32 planeReorderPossible; + VkBool32 persistentContent; +} VkDisplayPropertiesKHR; + +typedef struct VkDisplaySurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplaySurfaceCreateFlagsKHR flags; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkDisplaySurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( + VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + + +#define VK_KHR_display_swapchain 1 +#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10 +#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" +typedef struct VkDisplayPresentInfoKHR { + VkStructureType sType; + const void* pNext; + VkRect2D srcRect; + VkRect2D dstRect; + VkBool32 persistent; +} VkDisplayPresentInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains); +#endif + + +#define VK_KHR_sampler_mirror_clamp_to_edge 1 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" + + +#define VK_KHR_video_queue 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR) +#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION 8 +#define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue" + +typedef enum VkQueryResultStatusKHR { + VK_QUERY_RESULT_STATUS_ERROR_KHR = -1, + VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0, + VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1, + VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkQueryResultStatusKHR; + +typedef enum VkVideoCodecOperationFlagBitsKHR { + VK_VIDEO_CODEC_OPERATION_NONE_KHR = 0, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT = 0x00020000, +#endif + VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001, + VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002, + VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCodecOperationFlagBitsKHR; +typedef VkFlags VkVideoCodecOperationFlagsKHR; + +typedef enum VkVideoChromaSubsamplingFlagBitsKHR { + VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR = 0, + VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001, + VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002, + VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004, + VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008, + VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoChromaSubsamplingFlagBitsKHR; +typedef VkFlags VkVideoChromaSubsamplingFlagsKHR; + +typedef enum VkVideoComponentBitDepthFlagBitsKHR { + VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0, + VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001, + VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004, + VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010, + VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoComponentBitDepthFlagBitsKHR; +typedef VkFlags VkVideoComponentBitDepthFlagsKHR; + +typedef enum VkVideoCapabilityFlagBitsKHR { + VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002, + VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCapabilityFlagBitsKHR; +typedef VkFlags VkVideoCapabilityFlagsKHR; + +typedef enum VkVideoSessionCreateFlagBitsKHR { + VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoSessionCreateFlagBitsKHR; +typedef VkFlags VkVideoSessionCreateFlagsKHR; +typedef VkFlags VkVideoSessionParametersCreateFlagsKHR; +typedef VkFlags VkVideoBeginCodingFlagsKHR; +typedef VkFlags VkVideoEndCodingFlagsKHR; + +typedef enum VkVideoCodingControlFlagBitsKHR { + VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR = 0x00000002, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR = 0x00000004, +#endif + VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCodingControlFlagBitsKHR; +typedef VkFlags VkVideoCodingControlFlagsKHR; +typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 queryResultStatusSupport; +} VkQueueFamilyQueryResultStatusPropertiesKHR; + +typedef struct VkQueueFamilyVideoPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoCodecOperationFlagsKHR videoCodecOperations; +} VkQueueFamilyVideoPropertiesKHR; + +typedef struct VkVideoProfileInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoCodecOperationFlagBitsKHR videoCodecOperation; + VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; + VkVideoComponentBitDepthFlagsKHR lumaBitDepth; + VkVideoComponentBitDepthFlagsKHR chromaBitDepth; +} VkVideoProfileInfoKHR; + +typedef struct VkVideoProfileListInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t profileCount; + const VkVideoProfileInfoKHR* pProfiles; +} VkVideoProfileListInfoKHR; + +typedef struct VkVideoCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoCapabilityFlagsKHR flags; + VkDeviceSize minBitstreamBufferOffsetAlignment; + VkDeviceSize minBitstreamBufferSizeAlignment; + VkExtent2D pictureAccessGranularity; + VkExtent2D minCodedExtent; + VkExtent2D maxCodedExtent; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + VkExtensionProperties stdHeaderVersion; +} VkVideoCapabilitiesKHR; + +typedef struct VkPhysicalDeviceVideoFormatInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags imageUsage; +} VkPhysicalDeviceVideoFormatInfoKHR; + +typedef struct VkVideoFormatPropertiesKHR { + VkStructureType sType; + void* pNext; + VkFormat format; + VkComponentMapping componentMapping; + VkImageCreateFlags imageCreateFlags; + VkImageType imageType; + VkImageTiling imageTiling; + VkImageUsageFlags imageUsageFlags; +} VkVideoFormatPropertiesKHR; + +typedef struct VkVideoPictureResourceInfoKHR { + VkStructureType sType; + const void* pNext; + VkOffset2D codedOffset; + VkExtent2D codedExtent; + uint32_t baseArrayLayer; + VkImageView imageViewBinding; +} VkVideoPictureResourceInfoKHR; + +typedef struct VkVideoReferenceSlotInfoKHR { + VkStructureType sType; + const void* pNext; + int32_t slotIndex; + const VkVideoPictureResourceInfoKHR* pPictureResource; +} VkVideoReferenceSlotInfoKHR; + +typedef struct VkVideoSessionMemoryRequirementsKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryBindIndex; + VkMemoryRequirements memoryRequirements; +} VkVideoSessionMemoryRequirementsKHR; + +typedef struct VkBindVideoSessionMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t memoryBindIndex; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkDeviceSize memorySize; +} VkBindVideoSessionMemoryInfoKHR; + +typedef struct VkVideoSessionCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + VkVideoSessionCreateFlagsKHR flags; + const VkVideoProfileInfoKHR* pVideoProfile; + VkFormat pictureFormat; + VkExtent2D maxCodedExtent; + VkFormat referencePictureFormat; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + const VkExtensionProperties* pStdHeaderVersion; +} VkVideoSessionCreateInfoKHR; + +typedef struct VkVideoSessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoSessionParametersCreateFlagsKHR flags; + VkVideoSessionParametersKHR videoSessionParametersTemplate; + VkVideoSessionKHR videoSession; +} VkVideoSessionParametersCreateInfoKHR; + +typedef struct VkVideoSessionParametersUpdateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t updateSequenceCount; +} VkVideoSessionParametersUpdateInfoKHR; + +typedef struct VkVideoBeginCodingInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoBeginCodingFlagsKHR flags; + VkVideoSessionKHR videoSession; + VkVideoSessionParametersKHR videoSessionParameters; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotInfoKHR* pReferenceSlots; +} VkVideoBeginCodingInfoKHR; + +typedef struct VkVideoEndCodingInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEndCodingFlagsKHR flags; +} VkVideoEndCodingInfoKHR; + +typedef struct VkVideoCodingControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoCodingControlFlagsKHR flags; +} VkVideoCodingControlInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession); +typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); +typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters); +typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); +typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); +typedef void (VKAPI_PTR *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + const VkVideoProfileInfoKHR* pVideoProfile, + VkVideoCapabilitiesKHR* pCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, + uint32_t* pVideoFormatPropertyCount, + VkVideoFormatPropertiesKHR* pVideoFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR( + VkDevice device, + const VkVideoSessionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionKHR* pVideoSession); + +VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t* pMemoryRequirementsCount, + VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR( + VkDevice device, + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionParametersKHR* pVideoSessionParameters); + +VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); + +VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoBeginCodingInfoKHR* pBeginInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoEndCodingInfoKHR* pEndCodingInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoCodingControlInfoKHR* pCodingControlInfo); +#endif + + +#define VK_KHR_video_decode_queue 1 +#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 7 +#define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue" + +typedef enum VkVideoDecodeCapabilityFlagBitsKHR { + VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeCapabilityFlagBitsKHR; +typedef VkFlags VkVideoDecodeCapabilityFlagsKHR; + +typedef enum VkVideoDecodeUsageFlagBitsKHR { + VK_VIDEO_DECODE_USAGE_DEFAULT_KHR = 0, + VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR = 0x00000004, + VK_VIDEO_DECODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeUsageFlagBitsKHR; +typedef VkFlags VkVideoDecodeUsageFlagsKHR; +typedef VkFlags VkVideoDecodeFlagsKHR; +typedef struct VkVideoDecodeCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoDecodeCapabilityFlagsKHR flags; +} VkVideoDecodeCapabilitiesKHR; + +typedef struct VkVideoDecodeUsageInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoDecodeUsageFlagsKHR videoUsageHints; +} VkVideoDecodeUsageInfoKHR; + +typedef struct VkVideoDecodeInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoDecodeFlagsKHR flags; + VkBuffer srcBuffer; + VkDeviceSize srcBufferOffset; + VkDeviceSize srcBufferRange; + VkVideoPictureResourceInfoKHR dstPictureResource; + const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotInfoKHR* pReferenceSlots; +} VkVideoDecodeInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoDecodeInfoKHR* pDecodeInfo); +#endif + + +#define VK_KHR_video_decode_h264 1 +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_decode.h" +#define VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION 8 +#define VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME "VK_KHR_video_decode_h264" + +typedef enum VkVideoDecodeH264PictureLayoutFlagBitsKHR { + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR = 0, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeH264PictureLayoutFlagBitsKHR; +typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsKHR; +typedef struct VkVideoDecodeH264ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH264ProfileIdc stdProfileIdc; + VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout; +} VkVideoDecodeH264ProfileInfoKHR; + +typedef struct VkVideoDecodeH264CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoH264LevelIdc maxLevelIdc; + VkOffset2D fieldOffsetGranularity; +} VkVideoDecodeH264CapabilitiesKHR; + +typedef struct VkVideoDecodeH264SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdSPSCount; + const StdVideoH264SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH264PictureParameterSet* pStdPPSs; +} VkVideoDecodeH264SessionParametersAddInfoKHR; + +typedef struct VkVideoDecodeH264SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoDecodeH264SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeH264PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264PictureInfo* pStdPictureInfo; + uint32_t sliceCount; + const uint32_t* pSliceOffsets; +} VkVideoDecodeH264PictureInfoKHR; + +typedef struct VkVideoDecodeH264DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeH264DpbSlotInfoKHR; + + + +#define VK_KHR_dynamic_rendering 1 +#define VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION 1 +#define VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME "VK_KHR_dynamic_rendering" +typedef VkRenderingFlags VkRenderingFlagsKHR; + +typedef VkRenderingFlagBits VkRenderingFlagBitsKHR; + +typedef VkRenderingInfo VkRenderingInfoKHR; + +typedef VkRenderingAttachmentInfo VkRenderingAttachmentInfoKHR; + +typedef VkPipelineRenderingCreateInfo VkPipelineRenderingCreateInfoKHR; + +typedef VkPhysicalDeviceDynamicRenderingFeatures VkPhysicalDeviceDynamicRenderingFeaturesKHR; + +typedef VkCommandBufferInheritanceRenderingInfo VkCommandBufferInheritanceRenderingInfoKHR; + +typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkImageLayout imageLayout; + VkExtent2D shadingRateAttachmentTexelSize; +} VkRenderingFragmentShadingRateAttachmentInfoKHR; + +typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkImageLayout imageLayout; +} VkRenderingFragmentDensityMapAttachmentInfoEXT; + +typedef struct VkAttachmentSampleCountInfoAMD { + VkStructureType sType; + const void* pNext; + uint32_t colorAttachmentCount; + const VkSampleCountFlagBits* pColorAttachmentSamples; + VkSampleCountFlagBits depthStencilAttachmentSamples; +} VkAttachmentSampleCountInfoAMD; + +typedef VkAttachmentSampleCountInfoAMD VkAttachmentSampleCountInfoNV; + +typedef struct VkMultiviewPerViewAttributesInfoNVX { + VkStructureType sType; + const void* pNext; + VkBool32 perViewAttributes; + VkBool32 perViewAttributesPositionXOnly; +} VkMultiviewPerViewAttributesInfoNVX; + +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR( + VkCommandBuffer commandBuffer); +#endif + + +#define VK_KHR_multiview 1 +#define VK_KHR_MULTIVIEW_SPEC_VERSION 1 +#define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview" +typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR; + +typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR; + +typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR; + + + +#define VK_KHR_get_physical_device_properties2 1 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" +typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR; + +typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR; + +typedef VkFormatProperties2 VkFormatProperties2KHR; + +typedef VkImageFormatProperties2 VkImageFormatProperties2KHR; + +typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR; + +typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR; + +typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR; + +typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR; + +typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR; + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); +#endif + + +#define VK_KHR_device_group 1 +#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 4 +#define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group" +typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; + +typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR; + +typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR; + +typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR; + +typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR; + +typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR; + +typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR; + +typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR; + +typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR; + +typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR; + +typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); +#endif + + +#define VK_KHR_shader_draw_parameters 1 +#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 +#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" + + +#define VK_KHR_maintenance1 1 +#define VK_KHR_MAINTENANCE_1_SPEC_VERSION 2 +#define VK_KHR_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_maintenance1" +#define VK_KHR_MAINTENANCE1_SPEC_VERSION VK_KHR_MAINTENANCE_1_SPEC_VERSION +#define VK_KHR_MAINTENANCE1_EXTENSION_NAME VK_KHR_MAINTENANCE_1_EXTENSION_NAME +typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; + +typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); +#endif + + +#define VK_KHR_device_group_creation 1 +#define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1 +#define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation" +#define VK_MAX_DEVICE_GROUP_SIZE_KHR VK_MAX_DEVICE_GROUP_SIZE +typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR; + +typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +#endif + + +#define VK_KHR_external_memory_capabilities 1 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" +#define VK_LUID_SIZE_KHR VK_LUID_SIZE +typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR; + +typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR; + +typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR; + +typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR; + +typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR; + +typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR; + +typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR; + +typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR; + +typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR; + +typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR; + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); +#endif + + +#define VK_KHR_external_memory 1 +#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" +#define VK_QUEUE_FAMILY_EXTERNAL_KHR VK_QUEUE_FAMILY_EXTERNAL +typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR; + +typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR; + +typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR; + + + +#define VK_KHR_external_memory_fd 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" +typedef struct VkImportMemoryFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; +} VkImportMemoryFdInfoKHR; + +typedef struct VkMemoryFdPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHR; + +typedef struct VkMemoryGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties); +#endif + + +#define VK_KHR_external_semaphore_capabilities 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" +typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR; + +typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR; + +typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR; + +typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR; + +typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR; + +typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +#endif + + +#define VK_KHR_external_semaphore 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" +typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR; + +typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR; + +typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR; + + + +#define VK_KHR_external_semaphore_fd 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" +typedef struct VkImportSemaphoreFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + int fd; +} VkImportSemaphoreFdInfoKHR; + +typedef struct VkSemaphoreGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + + +#define VK_KHR_push_descriptor 1 +#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 +#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" +typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t maxPushDescriptors; +} VkPhysicalDevicePushDescriptorPropertiesKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData); +#endif + + +#define VK_KHR_shader_float16_int8 1 +#define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1 +#define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8" +typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR; + +typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR; + + + +#define VK_KHR_16bit_storage 1 +#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" +typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR; + + + +#define VK_KHR_incremental_present 1 +#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2 +#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" +typedef struct VkRectLayerKHR { + VkOffset2D offset; + VkExtent2D extent; + uint32_t layer; +} VkRectLayerKHR; + +typedef struct VkPresentRegionKHR { + uint32_t rectangleCount; + const VkRectLayerKHR* pRectangles; +} VkPresentRegionKHR; + +typedef struct VkPresentRegionsKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentRegionKHR* pRegions; +} VkPresentRegionsKHR; + + + +#define VK_KHR_descriptor_update_template 1 +typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR; + +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" +typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR; + +typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR; + +typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR; + +typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); +#endif + + +#define VK_KHR_imageless_framebuffer 1 +#define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1 +#define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer" +typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR; + +typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR; + +typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR; + +typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR; + + + +#define VK_KHR_create_renderpass2 1 +#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1 +#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2" +typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR; + +typedef VkAttachmentDescription2 VkAttachmentDescription2KHR; + +typedef VkAttachmentReference2 VkAttachmentReference2KHR; + +typedef VkSubpassDescription2 VkSubpassDescription2KHR; + +typedef VkSubpassDependency2 VkSubpassDependency2KHR; + +typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR; + +typedef VkSubpassEndInfo VkSubpassEndInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo); +#endif + + +#define VK_KHR_shared_presentable_image 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" +typedef struct VkSharedPresentSurfaceCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilitiesKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain); +#endif + + +#define VK_KHR_external_fence_capabilities 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" +typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR; + +typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR; + +typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR; + +typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR; + +typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR; + +typedef VkExternalFenceProperties VkExternalFencePropertiesKHR; + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); +#endif + + +#define VK_KHR_external_fence 1 +#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" +typedef VkFenceImportFlags VkFenceImportFlagsKHR; + +typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR; + +typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR; + + + +#define VK_KHR_external_fence_fd 1 +#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" +typedef struct VkImportFenceFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + int fd; +} VkImportFenceFdInfoKHR; + +typedef struct VkFenceGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + + +#define VK_KHR_performance_query 1 +#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 +#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query" + +typedef enum VkPerformanceCounterUnitKHR { + VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, + VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, + VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, + VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, + VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, + VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, + VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, + VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, + VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, + VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterUnitKHR; + +typedef enum VkPerformanceCounterScopeKHR { + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0, + VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1, + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2, + VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, + VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, + VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, + VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterScopeKHR; + +typedef enum VkPerformanceCounterStorageKHR { + VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, + VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, + VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, + VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, + VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterStorageKHR; + +typedef enum VkPerformanceCounterDescriptionFlagBitsKHR { + VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001, + VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002, + VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, + VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR, + VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterDescriptionFlagBitsKHR; +typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; + +typedef enum VkAcquireProfilingLockFlagBitsKHR { + VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAcquireProfilingLockFlagBitsKHR; +typedef VkFlags VkAcquireProfilingLockFlagsKHR; +typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 performanceCounterQueryPools; + VkBool32 performanceCounterMultipleQueryPools; +} VkPhysicalDevicePerformanceQueryFeaturesKHR; + +typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 allowCommandBufferQueryCopies; +} VkPhysicalDevicePerformanceQueryPropertiesKHR; + +typedef struct VkPerformanceCounterKHR { + VkStructureType sType; + void* pNext; + VkPerformanceCounterUnitKHR unit; + VkPerformanceCounterScopeKHR scope; + VkPerformanceCounterStorageKHR storage; + uint8_t uuid[VK_UUID_SIZE]; +} VkPerformanceCounterKHR; + +typedef struct VkPerformanceCounterDescriptionKHR { + VkStructureType sType; + void* pNext; + VkPerformanceCounterDescriptionFlagsKHR flags; + char name[VK_MAX_DESCRIPTION_SIZE]; + char category[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkPerformanceCounterDescriptionKHR; + +typedef struct VkQueryPoolPerformanceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + uint32_t counterIndexCount; + const uint32_t* pCounterIndices; +} VkQueryPoolPerformanceCreateInfoKHR; + +typedef union VkPerformanceCounterResultKHR { + int32_t int32; + int64_t int64; + uint32_t uint32; + uint64_t uint64; + float float32; + double float64; +} VkPerformanceCounterResultKHR; + +typedef struct VkAcquireProfilingLockInfoKHR { + VkStructureType sType; + const void* pNext; + VkAcquireProfilingLockFlagsKHR flags; + uint64_t timeout; +} VkAcquireProfilingLockInfoKHR; + +typedef struct VkPerformanceQuerySubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t counterPassIndex; +} VkPerformanceQuerySubmitInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + VkPhysicalDevice physicalDevice, + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, + uint32_t* pNumPasses); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR( + VkDevice device, + const VkAcquireProfilingLockInfoKHR* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR( + VkDevice device); +#endif + + +#define VK_KHR_maintenance2 1 +#define VK_KHR_MAINTENANCE_2_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_maintenance2" +#define VK_KHR_MAINTENANCE2_SPEC_VERSION VK_KHR_MAINTENANCE_2_SPEC_VERSION +#define VK_KHR_MAINTENANCE2_EXTENSION_NAME VK_KHR_MAINTENANCE_2_EXTENSION_NAME +typedef VkPointClippingBehavior VkPointClippingBehaviorKHR; + +typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR; + +typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR; + +typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR; + +typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR; + +typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR; + +typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR; + + + +#define VK_KHR_get_surface_capabilities2 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" +typedef struct VkPhysicalDeviceSurfaceInfo2KHR { + VkStructureType sType; + const void* pNext; + VkSurfaceKHR surface; +} VkPhysicalDeviceSurfaceInfo2KHR; + +typedef struct VkSurfaceCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceCapabilitiesKHR surfaceCapabilities; +} VkSurfaceCapabilities2KHR; + +typedef struct VkSurfaceFormat2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceFormatKHR surfaceFormat; +} VkSurfaceFormat2KHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); +#endif + + +#define VK_KHR_variable_pointers 1 +#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 +#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; + +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR; + + + +#define VK_KHR_get_display_properties2 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" +typedef struct VkDisplayProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPropertiesKHR displayProperties; +} VkDisplayProperties2KHR; + +typedef struct VkDisplayPlaneProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlanePropertiesKHR displayPlaneProperties; +} VkDisplayPlaneProperties2KHR; + +typedef struct VkDisplayModeProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayModePropertiesKHR displayModeProperties; +} VkDisplayModeProperties2KHR; + +typedef struct VkDisplayPlaneInfo2KHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeKHR mode; + uint32_t planeIndex; +} VkDisplayPlaneInfo2KHR; + +typedef struct VkDisplayPlaneCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlaneCapabilitiesKHR capabilities; +} VkDisplayPlaneCapabilities2KHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities); +#endif + + +#define VK_KHR_dedicated_allocation 1 +#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 +#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" +typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR; + +typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR; + + + +#define VK_KHR_storage_buffer_storage_class 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" + + +#define VK_KHR_relaxed_block_layout 1 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout" + + +#define VK_KHR_get_memory_requirements2 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" +typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR; + +typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR; + +typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR; + +typedef VkMemoryRequirements2 VkMemoryRequirements2KHR; + +typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR; + +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +#endif + + +#define VK_KHR_image_format_list 1 +#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1 +#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list" +typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR; + + + +#define VK_KHR_sampler_ycbcr_conversion 1 +typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR; + +#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14 +#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" +typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR; + +typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR; + +typedef VkChromaLocation VkChromaLocationKHR; + +typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR; + +typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR; + +typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR; + +typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR; + +typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; + +typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); +#endif + + +#define VK_KHR_bind_memory2 1 +#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1 +#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" +typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR; + +typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); +#endif + + +#define VK_KHR_maintenance3 1 +#define VK_KHR_MAINTENANCE_3_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_3_EXTENSION_NAME "VK_KHR_maintenance3" +#define VK_KHR_MAINTENANCE3_SPEC_VERSION VK_KHR_MAINTENANCE_3_SPEC_VERSION +#define VK_KHR_MAINTENANCE3_EXTENSION_NAME VK_KHR_MAINTENANCE_3_EXTENSION_NAME +typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR; + +typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR; + +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); +#endif + + +#define VK_KHR_draw_indirect_count 1 +#define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 +#define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count" +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + + +#define VK_KHR_shader_subgroup_extended_types 1 +#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1 +#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types" +typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; + + + +#define VK_KHR_8bit_storage 1 +#define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage" +typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR; + + + +#define VK_KHR_shader_atomic_int64 1 +#define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1 +#define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64" +typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR; + + + +#define VK_KHR_shader_clock 1 +#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1 +#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock" +typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupClock; + VkBool32 shaderDeviceClock; +} VkPhysicalDeviceShaderClockFeaturesKHR; + + + +#define VK_KHR_video_decode_h265 1 +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_decode.h" +#define VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION 7 +#define VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME "VK_KHR_video_decode_h265" +typedef struct VkVideoDecodeH265ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH265ProfileIdc stdProfileIdc; +} VkVideoDecodeH265ProfileInfoKHR; + +typedef struct VkVideoDecodeH265CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoH265LevelIdc maxLevelIdc; +} VkVideoDecodeH265CapabilitiesKHR; + +typedef struct VkVideoDecodeH265SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdVPSCount; + const StdVideoH265VideoParameterSet* pStdVPSs; + uint32_t stdSPSCount; + const StdVideoH265SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH265PictureParameterSet* pStdPPSs; +} VkVideoDecodeH265SessionParametersAddInfoKHR; + +typedef struct VkVideoDecodeH265SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdVPSCount; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoDecodeH265SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeH265PictureInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoDecodeH265PictureInfo* pStdPictureInfo; + uint32_t sliceSegmentCount; + const uint32_t* pSliceSegmentOffsets; +} VkVideoDecodeH265PictureInfoKHR; + +typedef struct VkVideoDecodeH265DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeH265DpbSlotInfoKHR; + + + +#define VK_KHR_global_priority 1 +#define VK_MAX_GLOBAL_PRIORITY_SIZE_KHR 16U +#define VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION 1 +#define VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME "VK_KHR_global_priority" + +typedef enum VkQueueGlobalPriorityKHR { + VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR = 128, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = 256, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = 512, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = 1024, + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR, + VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_KHR = 0x7FFFFFFF +} VkQueueGlobalPriorityKHR; +typedef struct VkDeviceQueueGlobalPriorityCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkQueueGlobalPriorityKHR globalPriority; +} VkDeviceQueueGlobalPriorityCreateInfoKHR; + +typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 globalPriorityQuery; +} VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR; + +typedef struct VkQueueFamilyGlobalPriorityPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t priorityCount; + VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR]; +} VkQueueFamilyGlobalPriorityPropertiesKHR; + + + +#define VK_KHR_driver_properties 1 +#define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1 +#define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties" +#define VK_MAX_DRIVER_NAME_SIZE_KHR VK_MAX_DRIVER_NAME_SIZE +#define VK_MAX_DRIVER_INFO_SIZE_KHR VK_MAX_DRIVER_INFO_SIZE +typedef VkDriverId VkDriverIdKHR; + +typedef VkConformanceVersion VkConformanceVersionKHR; + +typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR; + + + +#define VK_KHR_shader_float_controls 1 +#define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4 +#define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls" +typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR; + +typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR; + + + +#define VK_KHR_depth_stencil_resolve 1 +#define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1 +#define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve" +typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR; + +typedef VkResolveModeFlags VkResolveModeFlagsKHR; + +typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR; + +typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR; + + + +#define VK_KHR_swapchain_mutable_format 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format" + + +#define VK_KHR_timeline_semaphore 1 +#define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2 +#define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore" +typedef VkSemaphoreType VkSemaphoreTypeKHR; + +typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR; + +typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR; + +typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR; + +typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR; + +typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR; + +typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR; + +typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR; + +typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo); +#endif + + +#define VK_KHR_vulkan_memory_model 1 +#define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3 +#define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model" +typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR; + + + +#define VK_KHR_shader_terminate_invocation 1 +#define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1 +#define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation" +typedef VkPhysicalDeviceShaderTerminateInvocationFeatures VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR; + + + +#define VK_KHR_fragment_shading_rate 1 +#define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 2 +#define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate" + +typedef enum VkFragmentShadingRateCombinerOpKHR { + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF +} VkFragmentShadingRateCombinerOpKHR; +typedef struct VkFragmentShadingRateAttachmentInfoKHR { + VkStructureType sType; + const void* pNext; + const VkAttachmentReference2* pFragmentShadingRateAttachment; + VkExtent2D shadingRateAttachmentTexelSize; +} VkFragmentShadingRateAttachmentInfoKHR; + +typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExtent2D fragmentSize; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; +} VkPipelineFragmentShadingRateStateCreateInfoKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 pipelineFragmentShadingRate; + VkBool32 primitiveFragmentShadingRate; + VkBool32 attachmentFragmentShadingRate; +} VkPhysicalDeviceFragmentShadingRateFeaturesKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR { + VkStructureType sType; + void* pNext; + VkExtent2D minFragmentShadingRateAttachmentTexelSize; + VkExtent2D maxFragmentShadingRateAttachmentTexelSize; + uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + VkBool32 primitiveFragmentShadingRateWithMultipleViewports; + VkBool32 layeredShadingRateAttachments; + VkBool32 fragmentShadingRateNonTrivialCombinerOps; + VkExtent2D maxFragmentSize; + uint32_t maxFragmentSizeAspectRatio; + uint32_t maxFragmentShadingRateCoverageSamples; + VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; + VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; + VkBool32 fragmentShadingRateWithSampleMask; + VkBool32 fragmentShadingRateWithShaderSampleMask; + VkBool32 fragmentShadingRateWithConservativeRasterization; + VkBool32 fragmentShadingRateWithFragmentShaderInterlock; + VkBool32 fragmentShadingRateWithCustomSampleLocations; + VkBool32 fragmentShadingRateStrictMultiplyCombiner; +} VkPhysicalDeviceFragmentShadingRatePropertiesKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRateKHR { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleCounts; + VkExtent2D fragmentSize; +} VkPhysicalDeviceFragmentShadingRateKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); +typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR( + VkCommandBuffer commandBuffer, + const VkExtent2D* pFragmentSize, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); +#endif + + +#define VK_KHR_spirv_1_4 1 +#define VK_KHR_SPIRV_1_4_SPEC_VERSION 1 +#define VK_KHR_SPIRV_1_4_EXTENSION_NAME "VK_KHR_spirv_1_4" + + +#define VK_KHR_surface_protected_capabilities 1 +#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities" +typedef struct VkSurfaceProtectedCapabilitiesKHR { + VkStructureType sType; + const void* pNext; + VkBool32 supportsProtected; +} VkSurfaceProtectedCapabilitiesKHR; + + + +#define VK_KHR_separate_depth_stencil_layouts 1 +#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1 +#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts" +typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR; + +typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR; + +typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR; + + + +#define VK_KHR_present_wait 1 +#define VK_KHR_PRESENT_WAIT_SPEC_VERSION 1 +#define VK_KHR_PRESENT_WAIT_EXTENSION_NAME "VK_KHR_present_wait" +typedef struct VkPhysicalDevicePresentWaitFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 presentWait; +} VkPhysicalDevicePresentWaitFeaturesKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t presentId, + uint64_t timeout); +#endif + + +#define VK_KHR_uniform_buffer_standard_layout 1 +#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1 +#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout" +typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; + + + +#define VK_KHR_buffer_device_address 1 +#define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1 +#define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address" +typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR; + +typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR; + +typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR; + +typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR; + +typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR; + +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +#endif + + +#define VK_KHR_deferred_host_operations 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR) +#define VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION 4 +#define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations" +typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation); +typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator); +typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation); +typedef VkResult (VKAPI_PTR *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR( + VkDevice device, + const VkAllocationCallbacks* pAllocator, + VkDeferredOperationKHR* pDeferredOperation); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR( + VkDevice device, + VkDeferredOperationKHR operation, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR( + VkDevice device, + VkDeferredOperationKHR operation); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR( + VkDevice device, + VkDeferredOperationKHR operation); + +VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR( + VkDevice device, + VkDeferredOperationKHR operation); +#endif + + +#define VK_KHR_pipeline_executable_properties 1 +#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1 +#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties" + +typedef enum VkPipelineExecutableStatisticFormatKHR { + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPipelineExecutableStatisticFormatKHR; +typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 pipelineExecutableInfo; +} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + +typedef struct VkPipelineInfoKHR { + VkStructureType sType; + const void* pNext; + VkPipeline pipeline; +} VkPipelineInfoKHR; + +typedef struct VkPipelineExecutablePropertiesKHR { + VkStructureType sType; + void* pNext; + VkShaderStageFlags stages; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + uint32_t subgroupSize; +} VkPipelineExecutablePropertiesKHR; + +typedef struct VkPipelineExecutableInfoKHR { + VkStructureType sType; + const void* pNext; + VkPipeline pipeline; + uint32_t executableIndex; +} VkPipelineExecutableInfoKHR; + +typedef union VkPipelineExecutableStatisticValueKHR { + VkBool32 b32; + int64_t i64; + uint64_t u64; + double f64; +} VkPipelineExecutableStatisticValueKHR; + +typedef struct VkPipelineExecutableStatisticKHR { + VkStructureType sType; + void* pNext; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkPipelineExecutableStatisticFormatKHR format; + VkPipelineExecutableStatisticValueKHR value; +} VkPipelineExecutableStatisticKHR; + +typedef struct VkPipelineExecutableInternalRepresentationKHR { + VkStructureType sType; + void* pNext; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkBool32 isText; + size_t dataSize; + void* pData; +} VkPipelineExecutableInternalRepresentationKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR( + VkDevice device, + const VkPipelineInfoKHR* pPipelineInfo, + uint32_t* pExecutableCount, + VkPipelineExecutablePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pStatisticCount, + VkPipelineExecutableStatisticKHR* pStatistics); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pInternalRepresentationCount, + VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); +#endif + + +#define VK_KHR_map_memory2 1 +#define VK_KHR_MAP_MEMORY_2_SPEC_VERSION 1 +#define VK_KHR_MAP_MEMORY_2_EXTENSION_NAME "VK_KHR_map_memory2" +typedef VkFlags VkMemoryUnmapFlagsKHR; +typedef struct VkMemoryMapInfoKHR { + VkStructureType sType; + const void* pNext; + VkMemoryMapFlags flags; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMemoryMapInfoKHR; + +typedef struct VkMemoryUnmapInfoKHR { + VkStructureType sType; + const void* pNext; + VkMemoryUnmapFlagsKHR flags; + VkDeviceMemory memory; +} VkMemoryUnmapInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory2KHR)(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData); +typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2KHR)(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2KHR( + VkDevice device, + const VkMemoryMapInfoKHR* pMemoryMapInfo, + void** ppData); + +VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2KHR( + VkDevice device, + const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); +#endif + + +#define VK_KHR_shader_integer_dot_product 1 +#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION 1 +#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME "VK_KHR_shader_integer_dot_product" +typedef VkPhysicalDeviceShaderIntegerDotProductFeatures VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR; + +typedef VkPhysicalDeviceShaderIntegerDotProductProperties VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR; + + + +#define VK_KHR_pipeline_library 1 +#define VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION 1 +#define VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME "VK_KHR_pipeline_library" +typedef struct VkPipelineLibraryCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t libraryCount; + const VkPipeline* pLibraries; +} VkPipelineLibraryCreateInfoKHR; + + + +#define VK_KHR_shader_non_semantic_info 1 +#define VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION 1 +#define VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME "VK_KHR_shader_non_semantic_info" + + +#define VK_KHR_present_id 1 +#define VK_KHR_PRESENT_ID_SPEC_VERSION 1 +#define VK_KHR_PRESENT_ID_EXTENSION_NAME "VK_KHR_present_id" +typedef struct VkPresentIdKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint64_t* pPresentIds; +} VkPresentIdKHR; + +typedef struct VkPhysicalDevicePresentIdFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 presentId; +} VkPhysicalDevicePresentIdFeaturesKHR; + + + +#define VK_KHR_synchronization2 1 +#define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1 +#define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2" +typedef VkPipelineStageFlags2 VkPipelineStageFlags2KHR; + +typedef VkPipelineStageFlagBits2 VkPipelineStageFlagBits2KHR; + +typedef VkAccessFlags2 VkAccessFlags2KHR; + +typedef VkAccessFlagBits2 VkAccessFlagBits2KHR; + +typedef VkSubmitFlagBits VkSubmitFlagBitsKHR; + +typedef VkSubmitFlags VkSubmitFlagsKHR; + +typedef VkMemoryBarrier2 VkMemoryBarrier2KHR; + +typedef VkBufferMemoryBarrier2 VkBufferMemoryBarrier2KHR; + +typedef VkImageMemoryBarrier2 VkImageMemoryBarrier2KHR; + +typedef VkDependencyInfo VkDependencyInfoKHR; + +typedef VkSubmitInfo2 VkSubmitInfo2KHR; + +typedef VkSemaphoreSubmitInfo VkSemaphoreSubmitInfoKHR; + +typedef VkCommandBufferSubmitInfo VkCommandBufferSubmitInfoKHR; + +typedef VkPhysicalDeviceSynchronization2Features VkPhysicalDeviceSynchronization2FeaturesKHR; + +typedef struct VkQueueFamilyCheckpointProperties2NV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags2 checkpointExecutionStageMask; +} VkQueueFamilyCheckpointProperties2NV; + +typedef struct VkCheckpointData2NV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags2 stage; + void* pCheckpointMarker; +} VkCheckpointData2NV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); + +VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointData2NV* pCheckpointData); +#endif + + +#define VK_KHR_fragment_shader_barycentric 1 +#define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 +#define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_KHR_fragment_shader_barycentric" +typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShaderBarycentric; +} VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + +typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 triStripVertexOrderIndependentOfProvokingVertex; +} VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + + + +#define VK_KHR_shader_subgroup_uniform_control_flow 1 +#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION 1 +#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME "VK_KHR_shader_subgroup_uniform_control_flow" +typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupUniformControlFlow; +} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + + + +#define VK_KHR_zero_initialize_workgroup_memory 1 +#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION 1 +#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME "VK_KHR_zero_initialize_workgroup_memory" +typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR; + + + +#define VK_KHR_workgroup_memory_explicit_layout 1 +#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION 1 +#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME "VK_KHR_workgroup_memory_explicit_layout" +typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 workgroupMemoryExplicitLayout; + VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout; + VkBool32 workgroupMemoryExplicitLayout8BitAccess; + VkBool32 workgroupMemoryExplicitLayout16BitAccess; +} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + + + +#define VK_KHR_copy_commands2 1 +#define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1 +#define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2" +typedef VkCopyBufferInfo2 VkCopyBufferInfo2KHR; + +typedef VkCopyImageInfo2 VkCopyImageInfo2KHR; + +typedef VkCopyBufferToImageInfo2 VkCopyBufferToImageInfo2KHR; + +typedef VkCopyImageToBufferInfo2 VkCopyImageToBufferInfo2KHR; + +typedef VkBlitImageInfo2 VkBlitImageInfo2KHR; + +typedef VkResolveImageInfo2 VkResolveImageInfo2KHR; + +typedef VkBufferCopy2 VkBufferCopy2KHR; + +typedef VkImageCopy2 VkImageCopy2KHR; + +typedef VkImageBlit2 VkImageBlit2KHR; + +typedef VkBufferImageCopy2 VkBufferImageCopy2KHR; + +typedef VkImageResolve2 VkImageResolve2KHR; + +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo); +#endif + + +#define VK_KHR_format_feature_flags2 1 +#define VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION 2 +#define VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME "VK_KHR_format_feature_flags2" +typedef VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR; + +typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR; + +typedef VkFormatProperties3 VkFormatProperties3KHR; + + + +#define VK_KHR_ray_tracing_maintenance1 1 +#define VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_ray_tracing_maintenance1" +typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingMaintenance1; + VkBool32 rayTracingPipelineTraceRaysIndirect2; +} VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR; + +typedef struct VkTraceRaysIndirectCommand2KHR { + VkDeviceAddress raygenShaderRecordAddress; + VkDeviceSize raygenShaderRecordSize; + VkDeviceAddress missShaderBindingTableAddress; + VkDeviceSize missShaderBindingTableSize; + VkDeviceSize missShaderBindingTableStride; + VkDeviceAddress hitShaderBindingTableAddress; + VkDeviceSize hitShaderBindingTableSize; + VkDeviceSize hitShaderBindingTableStride; + VkDeviceAddress callableShaderBindingTableAddress; + VkDeviceSize callableShaderBindingTableSize; + VkDeviceSize callableShaderBindingTableStride; + uint32_t width; + uint32_t height; + uint32_t depth; +} VkTraceRaysIndirectCommand2KHR; + +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectDeviceAddress); +#endif + + +#define VK_KHR_portability_enumeration 1 +#define VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION 1 +#define VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME "VK_KHR_portability_enumeration" + + +#define VK_KHR_maintenance4 1 +#define VK_KHR_MAINTENANCE_4_SPEC_VERSION 2 +#define VK_KHR_MAINTENANCE_4_EXTENSION_NAME "VK_KHR_maintenance4" +typedef VkPhysicalDeviceMaintenance4Features VkPhysicalDeviceMaintenance4FeaturesKHR; + +typedef VkPhysicalDeviceMaintenance4Properties VkPhysicalDeviceMaintenance4PropertiesKHR; + +typedef VkDeviceBufferMemoryRequirements VkDeviceBufferMemoryRequirementsKHR; + +typedef VkDeviceImageMemoryRequirements VkDeviceImageMemoryRequirementsKHR; + +typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +#endif + + +#define VK_EXT_debug_report 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) +#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 10 +#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" + +typedef enum VkDebugReportObjectTypeEXT { + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, + VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, + VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, + VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, + VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, + VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, + VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, + VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, + VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, + VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, + VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, + VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, + VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, + VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000, + VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001, + VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000, + VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1000366000, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportObjectTypeEXT; + +typedef enum VkDebugReportFlagBitsEXT { + VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, + VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, + VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, + VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, + VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportFlagBitsEXT; +typedef VkFlags VkDebugReportFlagsEXT; +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + +typedef struct VkDebugReportCallbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData; +} VkDebugReportCallbackCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( + VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( + VkInstance instance, + VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( + VkInstance instance, + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage); +#endif + + +#define VK_NV_glsl_shader 1 +#define VK_NV_GLSL_SHADER_SPEC_VERSION 1 +#define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader" + + +#define VK_EXT_depth_range_unrestricted 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" + + +#define VK_IMG_filter_cubic 1 +#define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 +#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" + + +#define VK_AMD_rasterization_order 1 +#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 +#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order" + +typedef enum VkRasterizationOrderAMD { + VK_RASTERIZATION_ORDER_STRICT_AMD = 0, + VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, + VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF +} VkRasterizationOrderAMD; +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { + VkStructureType sType; + const void* pNext; + VkRasterizationOrderAMD rasterizationOrder; +} VkPipelineRasterizationStateRasterizationOrderAMD; + + + +#define VK_AMD_shader_trinary_minmax 1 +#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 +#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" + + +#define VK_AMD_shader_explicit_vertex_parameter 1 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" + + +#define VK_EXT_debug_marker 1 +#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 +#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" +typedef struct VkDebugMarkerObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName; +} VkDebugMarkerObjectNameInfoEXT; + +typedef struct VkDebugMarkerObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugMarkerObjectTagInfoEXT; + +typedef struct VkDebugMarkerMarkerInfoEXT { + VkStructureType sType; + const void* pNext; + const char* pMarkerName; + float color[4]; +} VkDebugMarkerMarkerInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( + VkDevice device, + const VkDebugMarkerObjectTagInfoEXT* pTagInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( + VkDevice device, + const VkDebugMarkerObjectNameInfoEXT* pNameInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +#endif + + +#define VK_AMD_gcn_shader 1 +#define VK_AMD_GCN_SHADER_SPEC_VERSION 1 +#define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" + + +#define VK_NV_dedicated_allocation 1 +#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 +#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" +typedef struct VkDedicatedAllocationImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationImageCreateInfoNV; + +typedef struct VkDedicatedAllocationBufferCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationBufferCreateInfoNV; + +typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkDedicatedAllocationMemoryAllocateInfoNV; + + + +#define VK_EXT_transform_feedback 1 +#define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1 +#define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback" +typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT; +typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 transformFeedback; + VkBool32 geometryStreams; +} VkPhysicalDeviceTransformFeedbackFeaturesEXT; + +typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxTransformFeedbackStreams; + uint32_t maxTransformFeedbackBuffers; + VkDeviceSize maxTransformFeedbackBufferSize; + uint32_t maxTransformFeedbackStreamDataSize; + uint32_t maxTransformFeedbackBufferDataSize; + uint32_t maxTransformFeedbackBufferDataStride; + VkBool32 transformFeedbackQueries; + VkBool32 transformFeedbackStreamsLinesTriangles; + VkBool32 transformFeedbackRasterizationStreamSelect; + VkBool32 transformFeedbackDraw; +} VkPhysicalDeviceTransformFeedbackPropertiesEXT; + +typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateStreamCreateFlagsEXT flags; + uint32_t rasterizationStream; +} VkPipelineRasterizationStateStreamCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); +typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); +typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags, + uint32_t index); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + uint32_t index); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT( + VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + VkBuffer counterBuffer, + VkDeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride); +#endif + + +#define VK_NVX_binary_import 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX) +#define VK_NVX_BINARY_IMPORT_SPEC_VERSION 1 +#define VK_NVX_BINARY_IMPORT_EXTENSION_NAME "VK_NVX_binary_import" +typedef struct VkCuModuleCreateInfoNVX { + VkStructureType sType; + const void* pNext; + size_t dataSize; + const void* pData; +} VkCuModuleCreateInfoNVX; + +typedef struct VkCuFunctionCreateInfoNVX { + VkStructureType sType; + const void* pNext; + VkCuModuleNVX module; + const char* pName; +} VkCuFunctionCreateInfoNVX; + +typedef struct VkCuLaunchInfoNVX { + VkStructureType sType; + const void* pNext; + VkCuFunctionNVX function; + uint32_t gridDimX; + uint32_t gridDimY; + uint32_t gridDimZ; + uint32_t blockDimX; + uint32_t blockDimY; + uint32_t blockDimZ; + uint32_t sharedMemBytes; + size_t paramCount; + const void* const * pParams; + size_t extraCount; + const void* const * pExtras; +} VkCuLaunchInfoNVX; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction); +typedef void (VKAPI_PTR *PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX( + VkDevice device, + const VkCuModuleCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuModuleNVX* pModule); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX( + VkDevice device, + const VkCuFunctionCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuFunctionNVX* pFunction); + +VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX( + VkDevice device, + VkCuModuleNVX module, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX( + VkDevice device, + VkCuFunctionNVX function, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX( + VkCommandBuffer commandBuffer, + const VkCuLaunchInfoNVX* pLaunchInfo); +#endif + + +#define VK_NVX_image_view_handle 1 +#define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 2 +#define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle" +typedef struct VkImageViewHandleInfoNVX { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkDescriptorType descriptorType; + VkSampler sampler; +} VkImageViewHandleInfoNVX; + +typedef struct VkImageViewAddressPropertiesNVX { + VkStructureType sType; + void* pNext; + VkDeviceAddress deviceAddress; + VkDeviceSize size; +} VkImageViewAddressPropertiesNVX; + +typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX( + VkDevice device, + const VkImageViewHandleInfoNVX* pInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX( + VkDevice device, + VkImageView imageView, + VkImageViewAddressPropertiesNVX* pProperties); +#endif + + +#define VK_AMD_draw_indirect_count 1 +#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2 +#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + + +#define VK_AMD_negative_viewport_height 1 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" + + +#define VK_AMD_gpu_shader_half_float 1 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" + + +#define VK_AMD_shader_ballot 1 +#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 +#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" + + +#define VK_AMD_texture_gather_bias_lod 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" +typedef struct VkTextureLODGatherFormatPropertiesAMD { + VkStructureType sType; + void* pNext; + VkBool32 supportsTextureGatherLODBiasAMD; +} VkTextureLODGatherFormatPropertiesAMD; + + + +#define VK_AMD_shader_info 1 +#define VK_AMD_SHADER_INFO_SPEC_VERSION 1 +#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" + +typedef enum VkShaderInfoTypeAMD { + VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, + VK_SHADER_INFO_TYPE_BINARY_AMD = 1, + VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, + VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkShaderInfoTypeAMD; +typedef struct VkShaderResourceUsageAMD { + uint32_t numUsedVgprs; + uint32_t numUsedSgprs; + uint32_t ldsSizePerLocalWorkGroup; + size_t ldsUsageSizeInBytes; + size_t scratchMemUsageInBytes; +} VkShaderResourceUsageAMD; + +typedef struct VkShaderStatisticsInfoAMD { + VkShaderStageFlags shaderStageMask; + VkShaderResourceUsageAMD resourceUsage; + uint32_t numPhysicalVgprs; + uint32_t numPhysicalSgprs; + uint32_t numAvailableVgprs; + uint32_t numAvailableSgprs; + uint32_t computeWorkGroupSize[3]; +} VkShaderStatisticsInfoAMD; + +typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( + VkDevice device, + VkPipeline pipeline, + VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, + size_t* pInfoSize, + void* pInfo); +#endif + + +#define VK_AMD_shader_image_load_store_lod 1 +#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 +#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" + + +#define VK_NV_corner_sampled_image 1 +#define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2 +#define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image" +typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cornerSampledImage; +} VkPhysicalDeviceCornerSampledImageFeaturesNV; + + + +#define VK_IMG_format_pvrtc 1 +#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 +#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" + + +#define VK_NV_external_memory_capabilities 1 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" + +typedef enum VkExternalMemoryHandleTypeFlagBitsNV { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBitsNV; +typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; + +typedef enum VkExternalMemoryFeatureFlagBitsNV { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBitsNV; +typedef VkFlags VkExternalMemoryFeatureFlagsNV; +typedef struct VkExternalImageFormatPropertiesNV { + VkImageFormatProperties imageFormatProperties; + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; +} VkExternalImageFormatPropertiesNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); +#endif + + +#define VK_NV_external_memory 1 +#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" +typedef struct VkExternalMemoryImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExternalMemoryImageCreateInfoNV; + +typedef struct VkExportMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExportMemoryAllocateInfoNV; + + + +#define VK_EXT_validation_flags 1 +#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 2 +#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" + +typedef enum VkValidationCheckEXT { + VK_VALIDATION_CHECK_ALL_EXT = 0, + VK_VALIDATION_CHECK_SHADERS_EXT = 1, + VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCheckEXT; +typedef struct VkValidationFlagsEXT { + VkStructureType sType; + const void* pNext; + uint32_t disabledValidationCheckCount; + const VkValidationCheckEXT* pDisabledValidationChecks; +} VkValidationFlagsEXT; + + + +#define VK_EXT_shader_subgroup_ballot 1 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" + + +#define VK_EXT_shader_subgroup_vote 1 +#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 +#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" + + +#define VK_EXT_texture_compression_astc_hdr 1 +#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1 +#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr" +typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; + + + +#define VK_EXT_astc_decode_mode 1 +#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1 +#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode" +typedef struct VkImageViewASTCDecodeModeEXT { + VkStructureType sType; + const void* pNext; + VkFormat decodeMode; +} VkImageViewASTCDecodeModeEXT; + +typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 decodeModeSharedExponent; +} VkPhysicalDeviceASTCDecodeFeaturesEXT; + + + +#define VK_EXT_pipeline_robustness 1 +#define VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_pipeline_robustness" + +typedef enum VkPipelineRobustnessBufferBehaviorEXT { + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = 0, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = 1, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = 2, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = 3, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPipelineRobustnessBufferBehaviorEXT; + +typedef enum VkPipelineRobustnessImageBehaviorEXT { + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = 0, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = 1, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = 2, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = 3, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPipelineRobustnessImageBehaviorEXT; +typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelineRobustness; +} VkPhysicalDevicePipelineRobustnessFeaturesEXT; + +typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT { + VkStructureType sType; + void* pNext; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs; + VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages; +} VkPhysicalDevicePipelineRobustnessPropertiesEXT; + +typedef struct VkPipelineRobustnessCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRobustnessBufferBehaviorEXT storageBuffers; + VkPipelineRobustnessBufferBehaviorEXT uniformBuffers; + VkPipelineRobustnessBufferBehaviorEXT vertexInputs; + VkPipelineRobustnessImageBehaviorEXT images; +} VkPipelineRobustnessCreateInfoEXT; + + + +#define VK_EXT_conditional_rendering 1 +#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2 +#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" + +typedef enum VkConditionalRenderingFlagBitsEXT { + VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, + VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConditionalRenderingFlagBitsEXT; +typedef VkFlags VkConditionalRenderingFlagsEXT; +typedef struct VkConditionalRenderingBeginInfoEXT { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceSize offset; + VkConditionalRenderingFlagsEXT flags; +} VkConditionalRenderingBeginInfoEXT; + +typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 conditionalRendering; + VkBool32 inheritedConditionalRendering; +} VkPhysicalDeviceConditionalRenderingFeaturesEXT; + +typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 conditionalRenderingEnable; +} VkCommandBufferInheritanceConditionalRenderingInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); +typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT( + VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT( + VkCommandBuffer commandBuffer); +#endif + + +#define VK_NV_clip_space_w_scaling 1 +#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 +#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" +typedef struct VkViewportWScalingNV { + float xcoeff; + float ycoeff; +} VkViewportWScalingNV; + +typedef struct VkPipelineViewportWScalingStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 viewportWScalingEnable; + uint32_t viewportCount; + const VkViewportWScalingNV* pViewportWScalings; +} VkPipelineViewportWScalingStateCreateInfoNV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV* pViewportWScalings); +#endif + + +#define VK_EXT_direct_mode_display 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" +typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); +#endif + + +#define VK_EXT_display_surface_counter 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" + +typedef enum VkSurfaceCounterFlagBitsEXT { + VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001, + VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT, + VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSurfaceCounterFlagBitsEXT; +typedef VkFlags VkSurfaceCounterFlagsEXT; +typedef struct VkSurfaceCapabilities2EXT { + VkStructureType sType; + void* pNext; + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; + VkSurfaceCounterFlagsEXT supportedSurfaceCounters; +} VkSurfaceCapabilities2EXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); +#endif + + +#define VK_EXT_display_control 1 +#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" + +typedef enum VkDisplayPowerStateEXT { + VK_DISPLAY_POWER_STATE_OFF_EXT = 0, + VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, + VK_DISPLAY_POWER_STATE_ON_EXT = 2, + VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayPowerStateEXT; + +typedef enum VkDeviceEventTypeEXT { + VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, + VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceEventTypeEXT; + +typedef enum VkDisplayEventTypeEXT { + VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, + VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayEventTypeEXT; +typedef struct VkDisplayPowerInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayPowerStateEXT powerState; +} VkDisplayPowerInfoEXT; + +typedef struct VkDeviceEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceEventTypeEXT deviceEvent; +} VkDeviceEventInfoEXT; + +typedef struct VkDisplayEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayEventTypeEXT displayEvent; +} VkDisplayEventInfoEXT; + +typedef struct VkSwapchainCounterCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSurfaceCounterFlagsEXT surfaceCounters; +} VkSwapchainCounterCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( + VkDevice device, + const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue); +#endif + + +#define VK_GOOGLE_display_timing 1 +#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 +#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" +typedef struct VkRefreshCycleDurationGOOGLE { + uint64_t refreshDuration; +} VkRefreshCycleDurationGOOGLE; + +typedef struct VkPastPresentationTimingGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; + uint64_t actualPresentTime; + uint64_t earliestPresentTime; + uint64_t presentMargin; +} VkPastPresentationTimingGOOGLE; + +typedef struct VkPresentTimeGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; +} VkPresentTimeGOOGLE; + +typedef struct VkPresentTimesInfoGOOGLE { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentTimeGOOGLE* pTimes; +} VkPresentTimesInfoGOOGLE; + +typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings); +#endif + + +#define VK_NV_sample_mask_override_coverage 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" + + +#define VK_NV_geometry_shader_passthrough 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" + + +#define VK_NV_viewport_array2 1 +#define VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME "VK_NV_viewport_array2" +#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION +#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME + + +#define VK_NVX_multiview_per_view_attributes 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" +typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + VkStructureType sType; + void* pNext; + VkBool32 perViewPositionAllComponents; +} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + + + +#define VK_NV_viewport_swizzle 1 +#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" + +typedef enum VkViewportCoordinateSwizzleNV { + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, + VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF +} VkViewportCoordinateSwizzleNV; +typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; +typedef struct VkViewportSwizzleNV { + VkViewportCoordinateSwizzleNV x; + VkViewportCoordinateSwizzleNV y; + VkViewportCoordinateSwizzleNV z; + VkViewportCoordinateSwizzleNV w; +} VkViewportSwizzleNV; + +typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const VkViewportSwizzleNV* pViewportSwizzles; +} VkPipelineViewportSwizzleStateCreateInfoNV; + + + +#define VK_EXT_discard_rectangles 1 +#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 2 +#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" + +typedef enum VkDiscardRectangleModeEXT { + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDiscardRectangleModeEXT; +typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT; + +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const VkRect2D* pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleModeEXT)(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 discardRectangleEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleModeEXT( + VkCommandBuffer commandBuffer, + VkDiscardRectangleModeEXT discardRectangleMode); +#endif + + +#define VK_EXT_conservative_rasterization 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" + +typedef enum VkConservativeRasterizationModeEXT { + VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, + VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, + VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, + VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConservativeRasterizationModeEXT; +typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; +} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; +} VkPipelineRasterizationConservativeStateCreateInfoEXT; + + + +#define VK_EXT_depth_clip_enable 1 +#define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable" +typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClipEnable; +} VkPhysicalDeviceDepthClipEnableFeaturesEXT; + +typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; + VkBool32 depthClipEnable; +} VkPipelineRasterizationDepthClipStateCreateInfoEXT; + + + +#define VK_EXT_swapchain_colorspace 1 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" + + +#define VK_EXT_hdr_metadata 1 +#define VK_EXT_HDR_METADATA_SPEC_VERSION 2 +#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" +typedef struct VkXYColorEXT { + float x; + float y; +} VkXYColorEXT; + +typedef struct VkHdrMetadataEXT { + VkStructureType sType; + const void* pNext; + VkXYColorEXT displayPrimaryRed; + VkXYColorEXT displayPrimaryGreen; + VkXYColorEXT displayPrimaryBlue; + VkXYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; +} VkHdrMetadataEXT; + +typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata); +#endif + + +#define VK_EXT_external_memory_dma_buf 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" + + +#define VK_EXT_queue_family_foreign 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" +#define VK_QUEUE_FAMILY_FOREIGN_EXT (~2U) + + +#define VK_EXT_debug_utils 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) +#define VK_EXT_DEBUG_UTILS_SPEC_VERSION 2 +#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" +typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; + +typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT { + VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugUtilsMessageSeverityFlagBitsEXT; + +typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { + VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, + VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, + VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT = 0x00000008, + VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugUtilsMessageTypeFlagBitsEXT; +typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; +typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; +typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; +typedef struct VkDebugUtilsLabelEXT { + VkStructureType sType; + const void* pNext; + const char* pLabelName; + float color[4]; +} VkDebugUtilsLabelEXT; + +typedef struct VkDebugUtilsObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + const char* pObjectName; +} VkDebugUtilsObjectNameInfoEXT; + +typedef struct VkDebugUtilsMessengerCallbackDataEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCallbackDataFlagsEXT flags; + const char* pMessageIdName; + int32_t messageIdNumber; + const char* pMessage; + uint32_t queueLabelCount; + const VkDebugUtilsLabelEXT* pQueueLabels; + uint32_t cmdBufLabelCount; + const VkDebugUtilsLabelEXT* pCmdBufLabels; + uint32_t objectCount; + const VkDebugUtilsObjectNameInfoEXT* pObjects; +} VkDebugUtilsMessengerCallbackDataEXT; + +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + +typedef struct VkDebugUtilsMessengerCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCreateFlagsEXT flags; + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageType; + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; + void* pUserData; +} VkDebugUtilsMessengerCreateInfoEXT; + +typedef struct VkDebugUtilsObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugUtilsObjectTagInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); +typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( + VkDevice device, + const VkDebugUtilsObjectNameInfoEXT* pNameInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( + VkDevice device, + const VkDebugUtilsObjectTagInfoEXT* pTagInfo); + +VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( + VkQueue queue); + +VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( + VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( + VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); +#endif + + +#define VK_EXT_sampler_filter_minmax 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2 +#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" +typedef VkSamplerReductionMode VkSamplerReductionModeEXT; + +typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT; + +typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + + + +#define VK_AMD_gpu_shader_int16 1 +#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 2 +#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" + + +#define VK_AMD_mixed_attachment_samples 1 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" + + +#define VK_AMD_shader_fragment_mask 1 +#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 +#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" + + +#define VK_EXT_inline_uniform_block 1 +#define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1 +#define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block" +typedef VkPhysicalDeviceInlineUniformBlockFeatures VkPhysicalDeviceInlineUniformBlockFeaturesEXT; + +typedef VkPhysicalDeviceInlineUniformBlockProperties VkPhysicalDeviceInlineUniformBlockPropertiesEXT; + +typedef VkWriteDescriptorSetInlineUniformBlock VkWriteDescriptorSetInlineUniformBlockEXT; + +typedef VkDescriptorPoolInlineUniformBlockCreateInfo VkDescriptorPoolInlineUniformBlockCreateInfoEXT; + + + +#define VK_EXT_shader_stencil_export 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" + + +#define VK_EXT_sample_locations 1 +#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 +#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" +typedef struct VkSampleLocationEXT { + float x; + float y; +} VkSampleLocationEXT; + +typedef struct VkSampleLocationsInfoEXT { + VkStructureType sType; + const void* pNext; + VkSampleCountFlagBits sampleLocationsPerPixel; + VkExtent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const VkSampleLocationEXT* pSampleLocations; +} VkSampleLocationsInfoEXT; + +typedef struct VkAttachmentSampleLocationsEXT { + uint32_t attachmentIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkAttachmentSampleLocationsEXT; + +typedef struct VkSubpassSampleLocationsEXT { + uint32_t subpassIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkSubpassSampleLocationsEXT; + +typedef struct VkRenderPassSampleLocationsBeginInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t attachmentInitialSampleLocationsCount; + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; +} VkRenderPassSampleLocationsBeginInfoEXT; + +typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 sampleLocationsEnable; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkPipelineSampleLocationsStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; +} VkPhysicalDeviceSampleLocationsPropertiesEXT; + +typedef struct VkMultisamplePropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D maxSampleLocationGridSize; +} VkMultisamplePropertiesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( + VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( + VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties); +#endif + + +#define VK_EXT_blend_operation_advanced 1 +#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 +#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" + +typedef enum VkBlendOverlapEXT { + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBlendOverlapEXT; +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + + + +#define VK_NV_fragment_coverage_to_color 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" +typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; +typedef struct VkPipelineCoverageToColorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; +} VkPipelineCoverageToColorStateCreateInfoNV; + + + +#define VK_NV_framebuffer_mixed_samples 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" + +typedef enum VkCoverageModulationModeNV { + VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, + VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, + VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, + VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, + VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoverageModulationModeNV; +typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; +typedef struct VkPipelineCoverageModulationStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageModulationStateCreateFlagsNV flags; + VkCoverageModulationModeNV coverageModulationMode; + VkBool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable; +} VkPipelineCoverageModulationStateCreateInfoNV; + + + +#define VK_NV_fill_rectangle 1 +#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 +#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" + + +#define VK_NV_shader_sm_builtins 1 +#define VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION 1 +#define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins" +typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t shaderSMCount; + uint32_t shaderWarpsPerSM; +} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV; + +typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shaderSMBuiltins; +} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV; + + + +#define VK_EXT_post_depth_coverage 1 +#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 +#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" + + +#define VK_EXT_image_drm_format_modifier 1 +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 2 +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier" +typedef struct VkDrmFormatModifierPropertiesEXT { + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags drmFormatModifierTilingFeatures; +} VkDrmFormatModifierPropertiesEXT; + +typedef struct VkDrmFormatModifierPropertiesListEXT { + VkStructureType sType; + void* pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesListEXT; + +typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT { + VkStructureType sType; + const void* pNext; + uint64_t drmFormatModifier; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkPhysicalDeviceImageDrmFormatModifierInfoEXT; + +typedef struct VkImageDrmFormatModifierListCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t drmFormatModifierCount; + const uint64_t* pDrmFormatModifiers; +} VkImageDrmFormatModifierListCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + const VkSubresourceLayout* pPlaneLayouts; +} VkImageDrmFormatModifierExplicitCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint64_t drmFormatModifier; +} VkImageDrmFormatModifierPropertiesEXT; + +typedef struct VkDrmFormatModifierProperties2EXT { + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags2 drmFormatModifierTilingFeatures; +} VkDrmFormatModifierProperties2EXT; + +typedef struct VkDrmFormatModifierPropertiesList2EXT { + VkStructureType sType; + void* pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesList2EXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT( + VkDevice device, + VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties); +#endif + + +#define VK_EXT_validation_cache 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) +#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 +#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" + +typedef enum VkValidationCacheHeaderVersionEXT { + VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, + VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCacheHeaderVersionEXT; +typedef VkFlags VkValidationCacheCreateFlagsEXT; +typedef struct VkValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheCreateFlagsEXT flags; + size_t initialDataSize; + const void* pInitialData; +} VkValidationCacheCreateInfoEXT; + +typedef struct VkShaderModuleValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheEXT validationCache; +} VkShaderModuleValidationCacheCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); +typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); +typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( + VkDevice device, + const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( + VkDevice device, + VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const VkValidationCacheEXT* pSrcCaches); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + size_t* pDataSize, + void* pData); +#endif + + +#define VK_EXT_descriptor_indexing 1 +#define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2 +#define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing" +typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT; + +typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT; + +typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; + +typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT; + +typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT; + +typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; + +typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; + + + +#define VK_EXT_shader_viewport_index_layer 1 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" + + +#define VK_NV_shading_rate_image 1 +#define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3 +#define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image" + +typedef enum VkShadingRatePaletteEntryNV { + VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0, + VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1, + VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2, + VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3, + VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11, + VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF +} VkShadingRatePaletteEntryNV; + +typedef enum VkCoarseSampleOrderTypeNV { + VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0, + VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1, + VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2, + VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3, + VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoarseSampleOrderTypeNV; +typedef struct VkShadingRatePaletteNV { + uint32_t shadingRatePaletteEntryCount; + const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries; +} VkShadingRatePaletteNV; + +typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 shadingRateImageEnable; + uint32_t viewportCount; + const VkShadingRatePaletteNV* pShadingRatePalettes; +} VkPipelineViewportShadingRateImageStateCreateInfoNV; + +typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shadingRateImage; + VkBool32 shadingRateCoarseSampleOrder; +} VkPhysicalDeviceShadingRateImageFeaturesNV; + +typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV { + VkStructureType sType; + void* pNext; + VkExtent2D shadingRateTexelSize; + uint32_t shadingRatePaletteSize; + uint32_t shadingRateMaxCoarseSamples; +} VkPhysicalDeviceShadingRateImagePropertiesNV; + +typedef struct VkCoarseSampleLocationNV { + uint32_t pixelX; + uint32_t pixelY; + uint32_t sample; +} VkCoarseSampleLocationNV; + +typedef struct VkCoarseSampleOrderCustomNV { + VkShadingRatePaletteEntryNV shadingRate; + uint32_t sampleCount; + uint32_t sampleLocationCount; + const VkCoarseSampleLocationNV* pSampleLocations; +} VkCoarseSampleOrderCustomNV; + +typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkCoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders; +} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; + +typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV* pShadingRatePalettes); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV( + VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); +#endif + + +#define VK_NV_ray_tracing 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV) +#define VK_NV_RAY_TRACING_SPEC_VERSION 3 +#define VK_NV_RAY_TRACING_EXTENSION_NAME "VK_NV_ray_tracing" +#define VK_SHADER_UNUSED_KHR (~0U) +#define VK_SHADER_UNUSED_NV VK_SHADER_UNUSED_KHR + +typedef enum VkRayTracingShaderGroupTypeKHR { + VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0, + VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1, + VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2, + VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR, + VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR, + VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR, + VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkRayTracingShaderGroupTypeKHR; +typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV; + + +typedef enum VkGeometryTypeKHR { + VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0, + VK_GEOMETRY_TYPE_AABBS_KHR = 1, + VK_GEOMETRY_TYPE_INSTANCES_KHR = 2, + VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR, + VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR, + VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkGeometryTypeKHR; +typedef VkGeometryTypeKHR VkGeometryTypeNV; + + +typedef enum VkAccelerationStructureTypeKHR { + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, + VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, + VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureTypeKHR; +typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV; + + +typedef enum VkCopyAccelerationStructureModeKHR { + VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0, + VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1, + VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2, + VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3, + VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR, + VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, + VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkCopyAccelerationStructureModeKHR; +typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV; + + +typedef enum VkAccelerationStructureMemoryRequirementsTypeNV { + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkAccelerationStructureMemoryRequirementsTypeNV; + +typedef enum VkGeometryFlagBitsKHR { + VK_GEOMETRY_OPAQUE_BIT_KHR = 0x00000001, + VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0x00000002, + VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR, + VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR, + VK_GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkGeometryFlagBitsKHR; +typedef VkFlags VkGeometryFlagsKHR; +typedef VkGeometryFlagsKHR VkGeometryFlagsNV; + +typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV; + + +typedef enum VkGeometryInstanceFlagBitsKHR { + VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0x00000001, + VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002, + VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004, + VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = 0x00000010, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000020, + VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, + VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, + VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkGeometryInstanceFlagBitsKHR; +typedef VkFlags VkGeometryInstanceFlagsKHR; +typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV; + +typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV; + + +typedef enum VkBuildAccelerationStructureFlagBitsKHR { + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0x00000001, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0x00000002, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0x00000004, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008, + VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010, + VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = 0x00000040, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000080, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = 0x00000100, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV = 0x00000200, +#endif + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkBuildAccelerationStructureFlagBitsKHR; +typedef VkFlags VkBuildAccelerationStructureFlagsKHR; +typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV; + +typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV; + +typedef struct VkRayTracingShaderGroupCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkRayTracingShaderGroupTypeKHR type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; +} VkRayTracingShaderGroupCreateInfoNV; + +typedef struct VkRayTracingPipelineCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const VkRayTracingShaderGroupCreateInfoNV* pGroups; + uint32_t maxRecursionDepth; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkRayTracingPipelineCreateInfoNV; + +typedef struct VkGeometryTrianglesNV { + VkStructureType sType; + const void* pNext; + VkBuffer vertexData; + VkDeviceSize vertexOffset; + uint32_t vertexCount; + VkDeviceSize vertexStride; + VkFormat vertexFormat; + VkBuffer indexData; + VkDeviceSize indexOffset; + uint32_t indexCount; + VkIndexType indexType; + VkBuffer transformData; + VkDeviceSize transformOffset; +} VkGeometryTrianglesNV; + +typedef struct VkGeometryAABBNV { + VkStructureType sType; + const void* pNext; + VkBuffer aabbData; + uint32_t numAABBs; + uint32_t stride; + VkDeviceSize offset; +} VkGeometryAABBNV; + +typedef struct VkGeometryDataNV { + VkGeometryTrianglesNV triangles; + VkGeometryAABBNV aabbs; +} VkGeometryDataNV; + +typedef struct VkGeometryNV { + VkStructureType sType; + const void* pNext; + VkGeometryTypeKHR geometryType; + VkGeometryDataNV geometry; + VkGeometryFlagsKHR flags; +} VkGeometryNV; + +typedef struct VkAccelerationStructureInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureTypeNV type; + VkBuildAccelerationStructureFlagsNV flags; + uint32_t instanceCount; + uint32_t geometryCount; + const VkGeometryNV* pGeometries; +} VkAccelerationStructureInfoNV; + +typedef struct VkAccelerationStructureCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceSize compactedSize; + VkAccelerationStructureInfoNV info; +} VkAccelerationStructureCreateInfoNV; + +typedef struct VkBindAccelerationStructureMemoryInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureNV accelerationStructure; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindAccelerationStructureMemoryInfoNV; + +typedef struct VkWriteDescriptorSetAccelerationStructureNV { + VkStructureType sType; + const void* pNext; + uint32_t accelerationStructureCount; + const VkAccelerationStructureNV* pAccelerationStructures; +} VkWriteDescriptorSetAccelerationStructureNV; + +typedef struct VkAccelerationStructureMemoryRequirementsInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureMemoryRequirementsTypeNV type; + VkAccelerationStructureNV accelerationStructure; +} VkAccelerationStructureMemoryRequirementsInfoNV; + +typedef struct VkPhysicalDeviceRayTracingPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t shaderGroupHandleSize; + uint32_t maxRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxTriangleCount; + uint32_t maxDescriptorSetAccelerationStructures; +} VkPhysicalDeviceRayTracingPropertiesNV; + +typedef struct VkTransformMatrixKHR { + float matrix[3][4]; +} VkTransformMatrixKHR; + +typedef VkTransformMatrixKHR VkTransformMatrixNV; + +typedef struct VkAabbPositionsKHR { + float minX; + float minY; + float minZ; + float maxX; + float maxY; + float maxZ; +} VkAabbPositionsKHR; + +typedef VkAabbPositionsKHR VkAabbPositionsNV; + +typedef struct VkAccelerationStructureInstanceKHR { + VkTransformMatrixKHR transform; + uint32_t instanceCustomIndex:24; + uint32_t mask:8; + uint32_t instanceShaderBindingTableRecordOffset:24; + VkGeometryInstanceFlagsKHR flags:8; + uint64_t accelerationStructureReference; +} VkAccelerationStructureInstanceKHR; + +typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure); +typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode); +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV( + VkDevice device, + const VkAccelerationStructureCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureNV* pAccelerationStructure); + +VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV( + VkDevice device, + const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV( + VkDevice device, + uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV( + VkCommandBuffer commandBuffer, + const VkAccelerationStructureInfoNV* pInfo, + VkBuffer instanceData, + VkDeviceSize instanceOffset, + VkBool32 update, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkBuffer scratch, + VkDeviceSize scratchOffset); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV( + VkCommandBuffer commandBuffer, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeKHR mode); + +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV( + VkCommandBuffer commandBuffer, + VkBuffer raygenShaderBindingTableBuffer, + VkDeviceSize raygenShaderBindingOffset, + VkBuffer missShaderBindingTableBuffer, + VkDeviceSize missShaderBindingOffset, + VkDeviceSize missShaderBindingStride, + VkBuffer hitShaderBindingTableBuffer, + VkDeviceSize hitShaderBindingOffset, + VkDeviceSize hitShaderBindingStride, + VkBuffer callableShaderBindingTableBuffer, + VkDeviceSize callableShaderBindingOffset, + VkDeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoNV* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + size_t dataSize, + void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureNV* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV( + VkDevice device, + VkPipeline pipeline, + uint32_t shader); +#endif + + +#define VK_NV_representative_fragment_test 1 +#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2 +#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test" +typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 representativeFragmentTest; +} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; + +typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 representativeFragmentTestEnable; +} VkPipelineRepresentativeFragmentTestStateCreateInfoNV; + + + +#define VK_EXT_filter_cubic 1 +#define VK_EXT_FILTER_CUBIC_SPEC_VERSION 3 +#define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic" +typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT { + VkStructureType sType; + void* pNext; + VkImageViewType imageViewType; +} VkPhysicalDeviceImageViewImageFormatInfoEXT; + +typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 filterCubic; + VkBool32 filterCubicMinmax; +} VkFilterCubicImageViewImageFormatPropertiesEXT; + + + +#define VK_QCOM_render_pass_shader_resolve 1 +#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION 4 +#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME "VK_QCOM_render_pass_shader_resolve" + + +#define VK_EXT_global_priority 1 +#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 +#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" +typedef VkQueueGlobalPriorityKHR VkQueueGlobalPriorityEXT; + +typedef VkDeviceQueueGlobalPriorityCreateInfoKHR VkDeviceQueueGlobalPriorityCreateInfoEXT; + + + +#define VK_EXT_external_memory_host 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" +typedef struct VkImportMemoryHostPointerInfoEXT { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + void* pHostPointer; +} VkImportMemoryHostPointerInfoEXT; + +typedef struct VkMemoryHostPointerPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryHostPointerPropertiesEXT; + +typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize minImportedHostPointerAlignment; +} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); +#endif + + +#define VK_AMD_buffer_marker 1 +#define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1 +#define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker" +typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); +#endif + + +#define VK_AMD_pipeline_compiler_control 1 +#define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1 +#define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control" + +typedef enum VkPipelineCompilerControlFlagBitsAMD { + VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF +} VkPipelineCompilerControlFlagBitsAMD; +typedef VkFlags VkPipelineCompilerControlFlagsAMD; +typedef struct VkPipelineCompilerControlCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkPipelineCompilerControlFlagsAMD compilerControlFlags; +} VkPipelineCompilerControlCreateInfoAMD; + + + +#define VK_EXT_calibrated_timestamps 1 +#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2 +#define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps" + +typedef enum VkTimeDomainEXT { + VK_TIME_DOMAIN_DEVICE_EXT = 0, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2, + VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3, + VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF +} VkTimeDomainEXT; +typedef struct VkCalibratedTimestampInfoEXT { + VkStructureType sType; + const void* pNext; + VkTimeDomainEXT timeDomain; +} VkCalibratedTimestampInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains); +typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainEXT* pTimeDomains); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoEXT* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation); +#endif + + +#define VK_AMD_shader_core_properties 1 +#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2 +#define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties" +typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { + VkStructureType sType; + void* pNext; + uint32_t shaderEngineCount; + uint32_t shaderArraysPerEngineCount; + uint32_t computeUnitsPerShaderArray; + uint32_t simdPerComputeUnit; + uint32_t wavefrontsPerSimd; + uint32_t wavefrontSize; + uint32_t sgprsPerSimd; + uint32_t minSgprAllocation; + uint32_t maxSgprAllocation; + uint32_t sgprAllocationGranularity; + uint32_t vgprsPerSimd; + uint32_t minVgprAllocation; + uint32_t maxVgprAllocation; + uint32_t vgprAllocationGranularity; +} VkPhysicalDeviceShaderCorePropertiesAMD; + + + +#define VK_AMD_memory_overallocation_behavior 1 +#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1 +#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior" + +typedef enum VkMemoryOverallocationBehaviorAMD { + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF +} VkMemoryOverallocationBehaviorAMD; +typedef struct VkDeviceMemoryOverallocationCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkMemoryOverallocationBehaviorAMD overallocationBehavior; +} VkDeviceMemoryOverallocationCreateInfoAMD; + + + +#define VK_EXT_vertex_attribute_divisor 1 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxVertexAttribDivisor; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; + +typedef struct VkVertexInputBindingDivisorDescriptionEXT { + uint32_t binding; + uint32_t divisor; +} VkVertexInputBindingDivisorDescriptionEXT; + +typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; +} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; + + + +#define VK_EXT_pipeline_creation_feedback 1 +#define VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME "VK_EXT_pipeline_creation_feedback" +typedef VkPipelineCreationFeedbackFlagBits VkPipelineCreationFeedbackFlagBitsEXT; + +typedef VkPipelineCreationFeedbackFlags VkPipelineCreationFeedbackFlagsEXT; + +typedef VkPipelineCreationFeedbackCreateInfo VkPipelineCreationFeedbackCreateInfoEXT; + +typedef VkPipelineCreationFeedback VkPipelineCreationFeedbackEXT; + + + +#define VK_NV_shader_subgroup_partitioned 1 +#define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1 +#define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned" + + +#define VK_NV_compute_shader_derivatives 1 +#define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 +#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives" +typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 computeDerivativeGroupQuads; + VkBool32 computeDerivativeGroupLinear; +} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; + + + +#define VK_NV_mesh_shader 1 +#define VK_NV_MESH_SHADER_SPEC_VERSION 1 +#define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader" +typedef struct VkPhysicalDeviceMeshShaderFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 taskShader; + VkBool32 meshShader; +} VkPhysicalDeviceMeshShaderFeaturesNV; + +typedef struct VkPhysicalDeviceMeshShaderPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxDrawMeshTasksCount; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskTotalMemorySize; + uint32_t maxTaskOutputCount; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshTotalMemorySize; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; +} VkPhysicalDeviceMeshShaderPropertiesNV; + +typedef struct VkDrawMeshTasksIndirectCommandNV { + uint32_t taskCount; + uint32_t firstTask; +} VkDrawMeshTasksIndirectCommandNV; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV( + VkCommandBuffer commandBuffer, + uint32_t taskCount, + uint32_t firstTask); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + + +#define VK_NV_fragment_shader_barycentric 1 +#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric" +typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; + + + +#define VK_NV_shader_image_footprint 1 +#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2 +#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint" +typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 imageFootprint; +} VkPhysicalDeviceShaderImageFootprintFeaturesNV; + + + +#define VK_NV_scissor_exclusive 1 +#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 2 +#define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive" +typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t exclusiveScissorCount; + const VkRect2D* pExclusiveScissors; +} VkPipelineViewportExclusiveScissorStateCreateInfoNV; + +typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 exclusiveScissor; +} VkPhysicalDeviceExclusiveScissorFeaturesNV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorEnableNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables); +typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorEnableNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkBool32* pExclusiveScissorEnables); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkRect2D* pExclusiveScissors); +#endif + + +#define VK_NV_device_diagnostic_checkpoints 1 +#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2 +#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints" +typedef struct VkQueueFamilyCheckpointPropertiesNV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags checkpointExecutionStageMask; +} VkQueueFamilyCheckpointPropertiesNV; + +typedef struct VkCheckpointDataNV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlagBits stage; + void* pCheckpointMarker; +} VkCheckpointDataNV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker); +typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV( + VkCommandBuffer commandBuffer, + const void* pCheckpointMarker); + +VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointDataNV* pCheckpointData); +#endif + + +#define VK_INTEL_shader_integer_functions2 1 +#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1 +#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2" +typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + VkStructureType sType; + void* pNext; + VkBool32 shaderIntegerFunctions2; +} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + + + +#define VK_INTEL_performance_query 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL) +#define VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION 2 +#define VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME "VK_INTEL_performance_query" + +typedef enum VkPerformanceConfigurationTypeINTEL { + VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0, + VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceConfigurationTypeINTEL; + +typedef enum VkQueryPoolSamplingModeINTEL { + VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0, + VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkQueryPoolSamplingModeINTEL; + +typedef enum VkPerformanceOverrideTypeINTEL { + VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0, + VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1, + VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceOverrideTypeINTEL; + +typedef enum VkPerformanceParameterTypeINTEL { + VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0, + VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1, + VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceParameterTypeINTEL; + +typedef enum VkPerformanceValueTypeINTEL { + VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0, + VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1, + VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2, + VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3, + VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4, + VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceValueTypeINTEL; +typedef union VkPerformanceValueDataINTEL { + uint32_t value32; + uint64_t value64; + float valueFloat; + VkBool32 valueBool; + const char* valueString; +} VkPerformanceValueDataINTEL; + +typedef struct VkPerformanceValueINTEL { + VkPerformanceValueTypeINTEL type; + VkPerformanceValueDataINTEL data; +} VkPerformanceValueINTEL; + +typedef struct VkInitializePerformanceApiInfoINTEL { + VkStructureType sType; + const void* pNext; + void* pUserData; +} VkInitializePerformanceApiInfoINTEL; + +typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL { + VkStructureType sType; + const void* pNext; + VkQueryPoolSamplingModeINTEL performanceCountersSampling; +} VkQueryPoolPerformanceQueryCreateInfoINTEL; + +typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL; + +typedef struct VkPerformanceMarkerInfoINTEL { + VkStructureType sType; + const void* pNext; + uint64_t marker; +} VkPerformanceMarkerInfoINTEL; + +typedef struct VkPerformanceStreamMarkerInfoINTEL { + VkStructureType sType; + const void* pNext; + uint32_t marker; +} VkPerformanceStreamMarkerInfoINTEL; + +typedef struct VkPerformanceOverrideInfoINTEL { + VkStructureType sType; + const void* pNext; + VkPerformanceOverrideTypeINTEL type; + VkBool32 enable; + uint64_t parameter; +} VkPerformanceOverrideInfoINTEL; + +typedef struct VkPerformanceConfigurationAcquireInfoINTEL { + VkStructureType sType; + const void* pNext; + VkPerformanceConfigurationTypeINTEL type; +} VkPerformanceConfigurationAcquireInfoINTEL; + +typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); +typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device); +typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo); +typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration); +typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration); +typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL( + VkDevice device, + const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); + +VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL( + VkDevice device); + +VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceMarkerInfoINTEL* pMarkerInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceOverrideInfoINTEL* pOverrideInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL( + VkDevice device, + const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, + VkPerformanceConfigurationINTEL* pConfiguration); + +VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL( + VkDevice device, + VkPerformanceConfigurationINTEL configuration); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL( + VkQueue queue, + VkPerformanceConfigurationINTEL configuration); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL( + VkDevice device, + VkPerformanceParameterTypeINTEL parameter, + VkPerformanceValueINTEL* pValue); +#endif + + +#define VK_EXT_pci_bus_info 1 +#define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2 +#define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info" +typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; +} VkPhysicalDevicePCIBusInfoPropertiesEXT; + + + +#define VK_AMD_display_native_hdr 1 +#define VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION 1 +#define VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME "VK_AMD_display_native_hdr" +typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD { + VkStructureType sType; + void* pNext; + VkBool32 localDimmingSupport; +} VkDisplayNativeHdrSurfaceCapabilitiesAMD; + +typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkBool32 localDimmingEnable; +} VkSwapchainDisplayNativeHdrCreateInfoAMD; + +typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD( + VkDevice device, + VkSwapchainKHR swapChain, + VkBool32 localDimmingEnable); +#endif + + +#define VK_EXT_fragment_density_map 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 2 +#define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map" +typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMap; + VkBool32 fragmentDensityMapDynamic; + VkBool32 fragmentDensityMapNonSubsampledImages; +} VkPhysicalDeviceFragmentDensityMapFeaturesEXT; + +typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D minFragmentDensityTexelSize; + VkExtent2D maxFragmentDensityTexelSize; + VkBool32 fragmentDensityInvocations; +} VkPhysicalDeviceFragmentDensityMapPropertiesEXT; + +typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkAttachmentReference fragmentDensityMapAttachment; +} VkRenderPassFragmentDensityMapCreateInfoEXT; + + + +#define VK_EXT_scalar_block_layout 1 +#define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1 +#define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout" +typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT; + + + +#define VK_GOOGLE_hlsl_functionality1 1 +#define VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION 1 +#define VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1" +#define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION +#define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME + + +#define VK_GOOGLE_decorate_string 1 +#define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1 +#define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string" + + +#define VK_EXT_subgroup_size_control 1 +#define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2 +#define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control" +typedef VkPhysicalDeviceSubgroupSizeControlFeatures VkPhysicalDeviceSubgroupSizeControlFeaturesEXT; + +typedef VkPhysicalDeviceSubgroupSizeControlProperties VkPhysicalDeviceSubgroupSizeControlPropertiesEXT; + +typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; + + + +#define VK_AMD_shader_core_properties2 1 +#define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1 +#define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2" + +typedef enum VkShaderCorePropertiesFlagBitsAMD { + VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF +} VkShaderCorePropertiesFlagBitsAMD; +typedef VkFlags VkShaderCorePropertiesFlagsAMD; +typedef struct VkPhysicalDeviceShaderCoreProperties2AMD { + VkStructureType sType; + void* pNext; + VkShaderCorePropertiesFlagsAMD shaderCoreFeatures; + uint32_t activeComputeUnitCount; +} VkPhysicalDeviceShaderCoreProperties2AMD; + + + +#define VK_AMD_device_coherent_memory 1 +#define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1 +#define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory" +typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD { + VkStructureType sType; + void* pNext; + VkBool32 deviceCoherentMemory; +} VkPhysicalDeviceCoherentMemoryFeaturesAMD; + + + +#define VK_EXT_shader_image_atomic_int64 1 +#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1 +#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64" +typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderImageInt64Atomics; + VkBool32 sparseImageInt64Atomics; +} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + + + +#define VK_EXT_memory_budget 1 +#define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1 +#define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget" +typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; + VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryBudgetPropertiesEXT; + + + +#define VK_EXT_memory_priority 1 +#define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1 +#define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority" +typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 memoryPriority; +} VkPhysicalDeviceMemoryPriorityFeaturesEXT; + +typedef struct VkMemoryPriorityAllocateInfoEXT { + VkStructureType sType; + const void* pNext; + float priority; +} VkMemoryPriorityAllocateInfoEXT; + + + +#define VK_NV_dedicated_allocation_image_aliasing 1 +#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1 +#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing" +typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 dedicatedAllocationImageAliasing; +} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + + + +#define VK_EXT_buffer_device_address 1 +#define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2 +#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address" +typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT; + +typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT; + +typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT; + +typedef struct VkBufferDeviceAddressCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceAddress deviceAddress; +} VkBufferDeviceAddressCreateInfoEXT; + +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); +#endif + + +#define VK_EXT_tooling_info 1 +#define VK_EXT_TOOLING_INFO_SPEC_VERSION 1 +#define VK_EXT_TOOLING_INFO_EXTENSION_NAME "VK_EXT_tooling_info" +typedef VkToolPurposeFlagBits VkToolPurposeFlagBitsEXT; + +typedef VkToolPurposeFlags VkToolPurposeFlagsEXT; + +typedef VkPhysicalDeviceToolProperties VkPhysicalDeviceToolPropertiesEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties); +#endif + + +#define VK_EXT_separate_stencil_usage 1 +#define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1 +#define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage" +typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT; + + + +#define VK_EXT_validation_features 1 +#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 5 +#define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features" + +typedef enum VkValidationFeatureEnableEXT { + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0, + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1, + VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2, + VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3, + VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4, + VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureEnableEXT; + +typedef enum VkValidationFeatureDisableEXT { + VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0, + VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1, + VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2, + VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3, + VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4, + VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5, + VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6, + VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7, + VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureDisableEXT; +typedef struct VkValidationFeaturesEXT { + VkStructureType sType; + const void* pNext; + uint32_t enabledValidationFeatureCount; + const VkValidationFeatureEnableEXT* pEnabledValidationFeatures; + uint32_t disabledValidationFeatureCount; + const VkValidationFeatureDisableEXT* pDisabledValidationFeatures; +} VkValidationFeaturesEXT; + + + +#define VK_NV_cooperative_matrix 1 +#define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1 +#define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix" + +typedef enum VkComponentTypeNV { + VK_COMPONENT_TYPE_FLOAT16_NV = 0, + VK_COMPONENT_TYPE_FLOAT32_NV = 1, + VK_COMPONENT_TYPE_FLOAT64_NV = 2, + VK_COMPONENT_TYPE_SINT8_NV = 3, + VK_COMPONENT_TYPE_SINT16_NV = 4, + VK_COMPONENT_TYPE_SINT32_NV = 5, + VK_COMPONENT_TYPE_SINT64_NV = 6, + VK_COMPONENT_TYPE_UINT8_NV = 7, + VK_COMPONENT_TYPE_UINT16_NV = 8, + VK_COMPONENT_TYPE_UINT32_NV = 9, + VK_COMPONENT_TYPE_UINT64_NV = 10, + VK_COMPONENT_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkComponentTypeNV; + +typedef enum VkScopeNV { + VK_SCOPE_DEVICE_NV = 1, + VK_SCOPE_WORKGROUP_NV = 2, + VK_SCOPE_SUBGROUP_NV = 3, + VK_SCOPE_QUEUE_FAMILY_NV = 5, + VK_SCOPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkScopeNV; +typedef struct VkCooperativeMatrixPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeNV AType; + VkComponentTypeNV BType; + VkComponentTypeNV CType; + VkComponentTypeNV DType; + VkScopeNV scope; +} VkCooperativeMatrixPropertiesNV; + +typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; +} VkPhysicalDeviceCooperativeMatrixFeaturesNV; + +typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV { + VkStructureType sType; + void* pNext; + VkShaderStageFlags cooperativeMatrixSupportedStages; +} VkPhysicalDeviceCooperativeMatrixPropertiesNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesNV* pProperties); +#endif + + +#define VK_NV_coverage_reduction_mode 1 +#define VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION 1 +#define VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME "VK_NV_coverage_reduction_mode" + +typedef enum VkCoverageReductionModeNV { + VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0, + VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1, + VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoverageReductionModeNV; +typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV; +typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 coverageReductionMode; +} VkPhysicalDeviceCoverageReductionModeFeaturesNV; + +typedef struct VkPipelineCoverageReductionStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageReductionStateCreateFlagsNV flags; + VkCoverageReductionModeNV coverageReductionMode; +} VkPipelineCoverageReductionStateCreateInfoNV; + +typedef struct VkFramebufferMixedSamplesCombinationNV { + VkStructureType sType; + void* pNext; + VkCoverageReductionModeNV coverageReductionMode; + VkSampleCountFlagBits rasterizationSamples; + VkSampleCountFlags depthStencilSamples; + VkSampleCountFlags colorSamples; +} VkFramebufferMixedSamplesCombinationNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + VkPhysicalDevice physicalDevice, + uint32_t* pCombinationCount, + VkFramebufferMixedSamplesCombinationNV* pCombinations); +#endif + + +#define VK_EXT_fragment_shader_interlock 1 +#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1 +#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock" +typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShaderSampleInterlock; + VkBool32 fragmentShaderPixelInterlock; + VkBool32 fragmentShaderShadingRateInterlock; +} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; + + + +#define VK_EXT_ycbcr_image_arrays 1 +#define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1 +#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays" +typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 ycbcrImageArrays; +} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; + + + +#define VK_EXT_provoking_vertex 1 +#define VK_EXT_PROVOKING_VERTEX_SPEC_VERSION 1 +#define VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME "VK_EXT_provoking_vertex" + +typedef enum VkProvokingVertexModeEXT { + VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0, + VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1, + VK_PROVOKING_VERTEX_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkProvokingVertexModeEXT; +typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 provokingVertexLast; + VkBool32 transformFeedbackPreservesProvokingVertex; +} VkPhysicalDeviceProvokingVertexFeaturesEXT; + +typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 provokingVertexModePerPipeline; + VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex; +} VkPhysicalDeviceProvokingVertexPropertiesEXT; + +typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkProvokingVertexModeEXT provokingVertexMode; +} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT; + + + +#define VK_EXT_headless_surface 1 +#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1 +#define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface" +typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; +typedef struct VkHeadlessSurfaceCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkHeadlessSurfaceCreateFlagsEXT flags; +} VkHeadlessSurfaceCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT( + VkInstance instance, + const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + + +#define VK_EXT_line_rasterization 1 +#define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1 +#define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization" + +typedef enum VkLineRasterizationModeEXT { + VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3, + VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkLineRasterizationModeEXT; +typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; +} VkPhysicalDeviceLineRasterizationFeaturesEXT; + +typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t lineSubPixelPrecisionBits; +} VkPhysicalDeviceLineRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationLineStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkLineRasterizationModeEXT lineRasterizationMode; + VkBool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; +} VkPipelineRasterizationLineStateCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern); +#endif + + +#define VK_EXT_shader_atomic_float 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float" +typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferFloat32Atomics; + VkBool32 shaderBufferFloat32AtomicAdd; + VkBool32 shaderBufferFloat64Atomics; + VkBool32 shaderBufferFloat64AtomicAdd; + VkBool32 shaderSharedFloat32Atomics; + VkBool32 shaderSharedFloat32AtomicAdd; + VkBool32 shaderSharedFloat64Atomics; + VkBool32 shaderSharedFloat64AtomicAdd; + VkBool32 shaderImageFloat32Atomics; + VkBool32 shaderImageFloat32AtomicAdd; + VkBool32 sparseImageFloat32Atomics; + VkBool32 sparseImageFloat32AtomicAdd; +} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; + + + +#define VK_EXT_host_query_reset 1 +#define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1 +#define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset" +typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); +#endif + + +#define VK_EXT_index_type_uint8 1 +#define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1 +#define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8" +typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 indexTypeUint8; +} VkPhysicalDeviceIndexTypeUint8FeaturesEXT; + + + +#define VK_EXT_extended_dynamic_state 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state" +typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState; +} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp); +#endif + + +#define VK_EXT_shader_atomic_float2 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME "VK_EXT_shader_atomic_float2" +typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferFloat16Atomics; + VkBool32 shaderBufferFloat16AtomicAdd; + VkBool32 shaderBufferFloat16AtomicMinMax; + VkBool32 shaderBufferFloat32AtomicMinMax; + VkBool32 shaderBufferFloat64AtomicMinMax; + VkBool32 shaderSharedFloat16Atomics; + VkBool32 shaderSharedFloat16AtomicAdd; + VkBool32 shaderSharedFloat16AtomicMinMax; + VkBool32 shaderSharedFloat32AtomicMinMax; + VkBool32 shaderSharedFloat64AtomicMinMax; + VkBool32 shaderImageFloat32AtomicMinMax; + VkBool32 sparseImageFloat32AtomicMinMax; +} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; + + + +#define VK_EXT_surface_maintenance1 1 +#define VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME "VK_EXT_surface_maintenance1" + +typedef enum VkPresentScalingFlagBitsEXT { + VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = 0x00000001, + VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = 0x00000002, + VK_PRESENT_SCALING_STRETCH_BIT_EXT = 0x00000004, + VK_PRESENT_SCALING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPresentScalingFlagBitsEXT; +typedef VkFlags VkPresentScalingFlagsEXT; + +typedef enum VkPresentGravityFlagBitsEXT { + VK_PRESENT_GRAVITY_MIN_BIT_EXT = 0x00000001, + VK_PRESENT_GRAVITY_MAX_BIT_EXT = 0x00000002, + VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = 0x00000004, + VK_PRESENT_GRAVITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPresentGravityFlagBitsEXT; +typedef VkFlags VkPresentGravityFlagsEXT; +typedef struct VkSurfacePresentModeEXT { + VkStructureType sType; + void* pNext; + VkPresentModeKHR presentMode; +} VkSurfacePresentModeEXT; + +typedef struct VkSurfacePresentScalingCapabilitiesEXT { + VkStructureType sType; + void* pNext; + VkPresentScalingFlagsEXT supportedPresentScaling; + VkPresentGravityFlagsEXT supportedPresentGravityX; + VkPresentGravityFlagsEXT supportedPresentGravityY; + VkExtent2D minScaledImageExtent; + VkExtent2D maxScaledImageExtent; +} VkSurfacePresentScalingCapabilitiesEXT; + +typedef struct VkSurfacePresentModeCompatibilityEXT { + VkStructureType sType; + void* pNext; + uint32_t presentModeCount; + VkPresentModeKHR* pPresentModes; +} VkSurfacePresentModeCompatibilityEXT; + + + +#define VK_EXT_swapchain_maintenance1 1 +#define VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME "VK_EXT_swapchain_maintenance1" +typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 swapchainMaintenance1; +} VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT; + +typedef struct VkSwapchainPresentFenceInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkFence* pFences; +} VkSwapchainPresentFenceInfoEXT; + +typedef struct VkSwapchainPresentModesCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t presentModeCount; + const VkPresentModeKHR* pPresentModes; +} VkSwapchainPresentModesCreateInfoEXT; + +typedef struct VkSwapchainPresentModeInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentModeKHR* pPresentModes; +} VkSwapchainPresentModeInfoEXT; + +typedef struct VkSwapchainPresentScalingCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPresentScalingFlagsEXT scalingBehavior; + VkPresentGravityFlagsEXT presentGravityX; + VkPresentGravityFlagsEXT presentGravityY; +} VkSwapchainPresentScalingCreateInfoEXT; + +typedef struct VkReleaseSwapchainImagesInfoEXT { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndexCount; + const uint32_t* pImageIndices; +} VkReleaseSwapchainImagesInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesEXT)(VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT( + VkDevice device, + const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); +#endif + + +#define VK_EXT_shader_demote_to_helper_invocation 1 +#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1 +#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation" +typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + + + +#define VK_NV_device_generated_commands 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV) +#define VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3 +#define VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NV_device_generated_commands" + +typedef enum VkIndirectCommandsTokenTypeNV { + VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV = 1000328000, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkIndirectCommandsTokenTypeNV; + +typedef enum VkIndirectStateFlagBitsNV { + VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001, + VK_INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkIndirectStateFlagBitsNV; +typedef VkFlags VkIndirectStateFlagsNV; + +typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV { + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0x00000002, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0x00000004, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkIndirectCommandsLayoutUsageFlagBitsNV; +typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV; +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxGraphicsShaderGroupCount; + uint32_t maxIndirectSequenceCount; + uint32_t maxIndirectCommandsTokenCount; + uint32_t maxIndirectCommandsStreamCount; + uint32_t maxIndirectCommandsTokenOffset; + uint32_t maxIndirectCommandsStreamStride; + uint32_t minSequencesCountBufferOffsetAlignment; + uint32_t minSequencesIndexBufferOffsetAlignment; + uint32_t minIndirectCommandsBufferOffsetAlignment; +} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 deviceGeneratedCommands; +} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + +typedef struct VkGraphicsShaderGroupCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; +} VkGraphicsShaderGroupCreateInfoNV; + +typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t groupCount; + const VkGraphicsShaderGroupCreateInfoNV* pGroups; + uint32_t pipelineCount; + const VkPipeline* pPipelines; +} VkGraphicsPipelineShaderGroupsCreateInfoNV; + +typedef struct VkBindShaderGroupIndirectCommandNV { + uint32_t groupIndex; +} VkBindShaderGroupIndirectCommandNV; + +typedef struct VkBindIndexBufferIndirectCommandNV { + VkDeviceAddress bufferAddress; + uint32_t size; + VkIndexType indexType; +} VkBindIndexBufferIndirectCommandNV; + +typedef struct VkBindVertexBufferIndirectCommandNV { + VkDeviceAddress bufferAddress; + uint32_t size; + uint32_t stride; +} VkBindVertexBufferIndirectCommandNV; + +typedef struct VkSetStateFlagsIndirectCommandNV { + uint32_t data; +} VkSetStateFlagsIndirectCommandNV; + +typedef struct VkIndirectCommandsStreamNV { + VkBuffer buffer; + VkDeviceSize offset; +} VkIndirectCommandsStreamNV; + +typedef struct VkIndirectCommandsLayoutTokenNV { + VkStructureType sType; + const void* pNext; + VkIndirectCommandsTokenTypeNV tokenType; + uint32_t stream; + uint32_t offset; + uint32_t vertexBindingUnit; + VkBool32 vertexDynamicStride; + VkPipelineLayout pushconstantPipelineLayout; + VkShaderStageFlags pushconstantShaderStageFlags; + uint32_t pushconstantOffset; + uint32_t pushconstantSize; + VkIndirectStateFlagsNV indirectStateFlags; + uint32_t indexTypeCount; + const VkIndexType* pIndexTypes; + const uint32_t* pIndexTypeValues; +} VkIndirectCommandsLayoutTokenNV; + +typedef struct VkIndirectCommandsLayoutCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkIndirectCommandsLayoutUsageFlagsNV flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t tokenCount; + const VkIndirectCommandsLayoutTokenNV* pTokens; + uint32_t streamCount; + const uint32_t* pStreamStrides; +} VkIndirectCommandsLayoutCreateInfoNV; + +typedef struct VkGeneratedCommandsInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline pipeline; + VkIndirectCommandsLayoutNV indirectCommandsLayout; + uint32_t streamCount; + const VkIndirectCommandsStreamNV* pStreams; + uint32_t sequencesCount; + VkBuffer preprocessBuffer; + VkDeviceSize preprocessOffset; + VkDeviceSize preprocessSize; + VkBuffer sequencesCountBuffer; + VkDeviceSize sequencesCountOffset; + VkBuffer sequencesIndexBuffer; + VkDeviceSize sequencesIndexOffset; +} VkGeneratedCommandsInfoNV; + +typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline pipeline; + VkIndirectCommandsLayoutNV indirectCommandsLayout; + uint32_t maxSequencesCount; +} VkGeneratedCommandsMemoryRequirementsInfoNV; + +typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex); +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline, + uint32_t groupIndex); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV( + VkDevice device, + VkIndirectCommandsLayoutNV indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); +#endif + + +#define VK_NV_inherited_viewport_scissor 1 +#define VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION 1 +#define VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME "VK_NV_inherited_viewport_scissor" +typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 inheritedViewportScissor2D; +} VkPhysicalDeviceInheritedViewportScissorFeaturesNV; + +typedef struct VkCommandBufferInheritanceViewportScissorInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 viewportScissor2D; + uint32_t viewportDepthCount; + const VkViewport* pViewportDepths; +} VkCommandBufferInheritanceViewportScissorInfoNV; + + + +#define VK_EXT_texel_buffer_alignment 1 +#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1 +#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment" +typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 texelBufferAlignment; +} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; + +typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT; + + + +#define VK_QCOM_render_pass_transform 1 +#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 3 +#define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform" +typedef struct VkRenderPassTransformBeginInfoQCOM { + VkStructureType sType; + void* pNext; + VkSurfaceTransformFlagBitsKHR transform; +} VkRenderPassTransformBeginInfoQCOM; + +typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM { + VkStructureType sType; + void* pNext; + VkSurfaceTransformFlagBitsKHR transform; + VkRect2D renderArea; +} VkCommandBufferInheritanceRenderPassTransformInfoQCOM; + + + +#define VK_EXT_device_memory_report 1 +#define VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION 2 +#define VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME "VK_EXT_device_memory_report" + +typedef enum VkDeviceMemoryReportEventTypeEXT { + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceMemoryReportEventTypeEXT; +typedef VkFlags VkDeviceMemoryReportFlagsEXT; +typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 deviceMemoryReport; +} VkPhysicalDeviceDeviceMemoryReportFeaturesEXT; + +typedef struct VkDeviceMemoryReportCallbackDataEXT { + VkStructureType sType; + void* pNext; + VkDeviceMemoryReportFlagsEXT flags; + VkDeviceMemoryReportEventTypeEXT type; + uint64_t memoryObjectId; + VkDeviceSize size; + VkObjectType objectType; + uint64_t objectHandle; + uint32_t heapIndex; +} VkDeviceMemoryReportCallbackDataEXT; + +typedef void (VKAPI_PTR *PFN_vkDeviceMemoryReportCallbackEXT)( + const VkDeviceMemoryReportCallbackDataEXT* pCallbackData, + void* pUserData); + +typedef struct VkDeviceDeviceMemoryReportCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceMemoryReportFlagsEXT flags; + PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback; + void* pUserData; +} VkDeviceDeviceMemoryReportCreateInfoEXT; + + + +#define VK_EXT_acquire_drm_display 1 +#define VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_drm_display" +typedef VkResult (VKAPI_PTR *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display); +typedef VkResult (VKAPI_PTR *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + VkDisplayKHR display); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + uint32_t connectorId, + VkDisplayKHR* display); +#endif + + +#define VK_EXT_robustness2 1 +#define VK_EXT_ROBUSTNESS_2_SPEC_VERSION 1 +#define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2" +typedef struct VkPhysicalDeviceRobustness2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 robustBufferAccess2; + VkBool32 robustImageAccess2; + VkBool32 nullDescriptor; +} VkPhysicalDeviceRobustness2FeaturesEXT; + +typedef struct VkPhysicalDeviceRobustness2PropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize robustStorageBufferAccessSizeAlignment; + VkDeviceSize robustUniformBufferAccessSizeAlignment; +} VkPhysicalDeviceRobustness2PropertiesEXT; + + + +#define VK_EXT_custom_border_color 1 +#define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12 +#define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color" +typedef struct VkSamplerCustomBorderColorCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkClearColorValue customBorderColor; + VkFormat format; +} VkSamplerCustomBorderColorCreateInfoEXT; + +typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxCustomBorderColorSamplers; +} VkPhysicalDeviceCustomBorderColorPropertiesEXT; + +typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 customBorderColors; + VkBool32 customBorderColorWithoutFormat; +} VkPhysicalDeviceCustomBorderColorFeaturesEXT; + + + +#define VK_GOOGLE_user_type 1 +#define VK_GOOGLE_USER_TYPE_SPEC_VERSION 1 +#define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type" + + +#define VK_NV_present_barrier 1 +#define VK_NV_PRESENT_BARRIER_SPEC_VERSION 1 +#define VK_NV_PRESENT_BARRIER_EXTENSION_NAME "VK_NV_present_barrier" +typedef struct VkPhysicalDevicePresentBarrierFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrier; +} VkPhysicalDevicePresentBarrierFeaturesNV; + +typedef struct VkSurfaceCapabilitiesPresentBarrierNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrierSupported; +} VkSurfaceCapabilitiesPresentBarrierNV; + +typedef struct VkSwapchainPresentBarrierCreateInfoNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrierEnable; +} VkSwapchainPresentBarrierCreateInfoNV; + + + +#define VK_EXT_private_data 1 +typedef VkPrivateDataSlot VkPrivateDataSlotEXT; + +#define VK_EXT_PRIVATE_DATA_SPEC_VERSION 1 +#define VK_EXT_PRIVATE_DATA_EXTENSION_NAME "VK_EXT_private_data" +typedef VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT; + +typedef VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataFeaturesEXT; + +typedef VkDevicePrivateDataCreateInfo VkDevicePrivateDataCreateInfoEXT; + +typedef VkPrivateDataSlotCreateInfo VkPrivateDataSlotCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +typedef void (VKAPI_PTR *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data); + +VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData); +#endif + + +#define VK_EXT_pipeline_creation_cache_control 1 +#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION 3 +#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME "VK_EXT_pipeline_creation_cache_control" +typedef VkPhysicalDevicePipelineCreationCacheControlFeatures VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT; + + + +#define VK_NV_device_diagnostics_config 1 +#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION 2 +#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config" + +typedef enum VkDeviceDiagnosticsConfigFlagBitsNV { + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001, + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0x00000002, + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0x00000004, + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV = 0x00000008, + VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkDeviceDiagnosticsConfigFlagBitsNV; +typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV; +typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 diagnosticsConfig; +} VkPhysicalDeviceDiagnosticsConfigFeaturesNV; + +typedef struct VkDeviceDiagnosticsConfigCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceDiagnosticsConfigFlagsNV flags; +} VkDeviceDiagnosticsConfigCreateInfoNV; + + + +#define VK_QCOM_render_pass_store_ops 1 +#define VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION 2 +#define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops" + + +#define VK_NV_low_latency 1 +#define VK_NV_LOW_LATENCY_SPEC_VERSION 1 +#define VK_NV_LOW_LATENCY_EXTENSION_NAME "VK_NV_low_latency" +typedef struct VkQueryLowLatencySupportNV { + VkStructureType sType; + const void* pNext; + void* pQueriedLowLatencyData; +} VkQueryLowLatencySupportNV; + + + +#define VK_EXT_descriptor_buffer 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) +#define VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION 1 +#define VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME "VK_EXT_descriptor_buffer" +typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 combinedImageSamplerDescriptorSingleArray; + VkBool32 bufferlessPushDescriptors; + VkBool32 allowSamplerImageViewPostSubmitCreation; + VkDeviceSize descriptorBufferOffsetAlignment; + uint32_t maxDescriptorBufferBindings; + uint32_t maxResourceDescriptorBufferBindings; + uint32_t maxSamplerDescriptorBufferBindings; + uint32_t maxEmbeddedImmutableSamplerBindings; + uint32_t maxEmbeddedImmutableSamplers; + size_t bufferCaptureReplayDescriptorDataSize; + size_t imageCaptureReplayDescriptorDataSize; + size_t imageViewCaptureReplayDescriptorDataSize; + size_t samplerCaptureReplayDescriptorDataSize; + size_t accelerationStructureCaptureReplayDescriptorDataSize; + size_t samplerDescriptorSize; + size_t combinedImageSamplerDescriptorSize; + size_t sampledImageDescriptorSize; + size_t storageImageDescriptorSize; + size_t uniformTexelBufferDescriptorSize; + size_t robustUniformTexelBufferDescriptorSize; + size_t storageTexelBufferDescriptorSize; + size_t robustStorageTexelBufferDescriptorSize; + size_t uniformBufferDescriptorSize; + size_t robustUniformBufferDescriptorSize; + size_t storageBufferDescriptorSize; + size_t robustStorageBufferDescriptorSize; + size_t inputAttachmentDescriptorSize; + size_t accelerationStructureDescriptorSize; + VkDeviceSize maxSamplerDescriptorBufferRange; + VkDeviceSize maxResourceDescriptorBufferRange; + VkDeviceSize samplerDescriptorBufferAddressSpaceSize; + VkDeviceSize resourceDescriptorBufferAddressSpaceSize; + VkDeviceSize descriptorBufferAddressSpaceSize; +} VkPhysicalDeviceDescriptorBufferPropertiesEXT; + +typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext; + size_t combinedImageSamplerDensityMapDescriptorSize; +} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + +typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 descriptorBuffer; + VkBool32 descriptorBufferCaptureReplay; + VkBool32 descriptorBufferImageLayoutIgnored; + VkBool32 descriptorBufferPushDescriptors; +} VkPhysicalDeviceDescriptorBufferFeaturesEXT; + +typedef struct VkDescriptorAddressInfoEXT { + VkStructureType sType; + void* pNext; + VkDeviceAddress address; + VkDeviceSize range; + VkFormat format; +} VkDescriptorAddressInfoEXT; + +typedef struct VkDescriptorBufferBindingInfoEXT { + VkStructureType sType; + void* pNext; + VkDeviceAddress address; + VkBufferUsageFlags usage; +} VkDescriptorBufferBindingInfoEXT; + +typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT { + VkStructureType sType; + void* pNext; + VkBuffer buffer; +} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT; + +typedef union VkDescriptorDataEXT { + const VkSampler* pSampler; + const VkDescriptorImageInfo* pCombinedImageSampler; + const VkDescriptorImageInfo* pInputAttachmentImage; + const VkDescriptorImageInfo* pSampledImage; + const VkDescriptorImageInfo* pStorageImage; + const VkDescriptorAddressInfoEXT* pUniformTexelBuffer; + const VkDescriptorAddressInfoEXT* pStorageTexelBuffer; + const VkDescriptorAddressInfoEXT* pUniformBuffer; + const VkDescriptorAddressInfoEXT* pStorageBuffer; + VkDeviceAddress accelerationStructure; +} VkDescriptorDataEXT; + +typedef struct VkDescriptorGetInfoEXT { + VkStructureType sType; + const void* pNext; + VkDescriptorType type; + VkDescriptorDataEXT data; +} VkDescriptorGetInfoEXT; + +typedef struct VkBufferCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferCaptureDescriptorDataInfoEXT; + +typedef struct VkImageCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageCaptureDescriptorDataInfoEXT; + +typedef struct VkImageViewCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageView imageView; +} VkImageViewCaptureDescriptorDataInfoEXT; + +typedef struct VkSamplerCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkSampler sampler; +} VkSamplerCaptureDescriptorDataInfoEXT; + +typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT { + VkStructureType sType; + const void* pNext; + const void* opaqueCaptureDescriptorData; +} VkOpaqueCaptureDescriptorDataCreateInfoEXT; + +typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR accelerationStructure; + VkAccelerationStructureNV accelerationStructureNV; +} VkAccelerationStructureCaptureDescriptorDataInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos); +typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set); +typedef VkResult (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT( + VkDevice device, + VkDescriptorSetLayout layout, + VkDeviceSize* pLayoutSizeInBytes); + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT( + VkDevice device, + VkDescriptorSetLayout layout, + uint32_t binding, + VkDeviceSize* pOffset); + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT( + VkDevice device, + const VkDescriptorGetInfoEXT* pDescriptorInfo, + size_t dataSize, + void* pDescriptor); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const uint32_t* pBufferIndices, + const VkDeviceSize* pOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkBufferCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, + void* pData); +#endif + + +#define VK_EXT_graphics_pipeline_library 1 +#define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION 1 +#define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME "VK_EXT_graphics_pipeline_library" + +typedef enum VkGraphicsPipelineLibraryFlagBitsEXT { + VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT = 0x00000001, + VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT = 0x00000002, + VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT = 0x00000004, + VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT = 0x00000008, + VK_GRAPHICS_PIPELINE_LIBRARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkGraphicsPipelineLibraryFlagBitsEXT; +typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT; +typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 graphicsPipelineLibrary; +} VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + +typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 graphicsPipelineLibraryFastLinking; + VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration; +} VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + +typedef struct VkGraphicsPipelineLibraryCreateInfoEXT { + VkStructureType sType; + void* pNext; + VkGraphicsPipelineLibraryFlagsEXT flags; +} VkGraphicsPipelineLibraryCreateInfoEXT; + + + +#define VK_AMD_shader_early_and_late_fragment_tests 1 +#define VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION 1 +#define VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME "VK_AMD_shader_early_and_late_fragment_tests" +typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + VkStructureType sType; + void* pNext; + VkBool32 shaderEarlyAndLateFragmentTests; +} VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + + + +#define VK_NV_fragment_shading_rate_enums 1 +#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME "VK_NV_fragment_shading_rate_enums" + +typedef enum VkFragmentShadingRateTypeNV { + VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0, + VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1, + VK_FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkFragmentShadingRateTypeNV; + +typedef enum VkFragmentShadingRateNV { + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10, + VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11, + VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12, + VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13, + VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14, + VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15, + VK_FRAGMENT_SHADING_RATE_MAX_ENUM_NV = 0x7FFFFFFF +} VkFragmentShadingRateNV; +typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShadingRateEnums; + VkBool32 supersampleFragmentShadingRates; + VkBool32 noInvocationFragmentShadingRates; +} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + +typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + VkStructureType sType; + void* pNext; + VkSampleCountFlagBits maxFragmentShadingRateInvocationCount; +} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + +typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkFragmentShadingRateTypeNV shadingRateType; + VkFragmentShadingRateNV shadingRate; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; +} VkPipelineFragmentShadingRateEnumStateCreateInfoNV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV( + VkCommandBuffer commandBuffer, + VkFragmentShadingRateNV shadingRate, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); +#endif + + +#define VK_NV_ray_tracing_motion_blur 1 +#define VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION 1 +#define VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME "VK_NV_ray_tracing_motion_blur" + +typedef enum VkAccelerationStructureMotionInstanceTypeNV { + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0, + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1, + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2, + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkAccelerationStructureMotionInstanceTypeNV; +typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV; +typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV; +typedef union VkDeviceOrHostAddressConstKHR { + VkDeviceAddress deviceAddress; + const void* hostAddress; +} VkDeviceOrHostAddressConstKHR; + +typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR vertexData; +} VkAccelerationStructureGeometryMotionTrianglesDataNV; + +typedef struct VkAccelerationStructureMotionInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t maxInstances; + VkAccelerationStructureMotionInfoFlagsNV flags; +} VkAccelerationStructureMotionInfoNV; + +typedef struct VkAccelerationStructureMatrixMotionInstanceNV { + VkTransformMatrixKHR transformT0; + VkTransformMatrixKHR transformT1; + uint32_t instanceCustomIndex:24; + uint32_t mask:8; + uint32_t instanceShaderBindingTableRecordOffset:24; + VkGeometryInstanceFlagsKHR flags:8; + uint64_t accelerationStructureReference; +} VkAccelerationStructureMatrixMotionInstanceNV; + +typedef struct VkSRTDataNV { + float sx; + float a; + float b; + float pvx; + float sy; + float c; + float pvy; + float sz; + float pvz; + float qx; + float qy; + float qz; + float qw; + float tx; + float ty; + float tz; +} VkSRTDataNV; + +typedef struct VkAccelerationStructureSRTMotionInstanceNV { + VkSRTDataNV transformT0; + VkSRTDataNV transformT1; + uint32_t instanceCustomIndex:24; + uint32_t mask:8; + uint32_t instanceShaderBindingTableRecordOffset:24; + VkGeometryInstanceFlagsKHR flags:8; + uint64_t accelerationStructureReference; +} VkAccelerationStructureSRTMotionInstanceNV; + +typedef union VkAccelerationStructureMotionInstanceDataNV { + VkAccelerationStructureInstanceKHR staticInstance; + VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance; + VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance; +} VkAccelerationStructureMotionInstanceDataNV; + +typedef struct VkAccelerationStructureMotionInstanceNV { + VkAccelerationStructureMotionInstanceTypeNV type; + VkAccelerationStructureMotionInstanceFlagsNV flags; + VkAccelerationStructureMotionInstanceDataNV data; +} VkAccelerationStructureMotionInstanceNV; + +typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingMotionBlur; + VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect; +} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV; + + + +#define VK_EXT_ycbcr_2plane_444_formats 1 +#define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1 +#define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats" +typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 ycbcr2plane444Formats; +} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + + + +#define VK_EXT_fragment_density_map2 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME "VK_EXT_fragment_density_map2" +typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMapDeferred; +} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT; + +typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 subsampledLoads; + VkBool32 subsampledCoarseReconstructionEarlyAccess; + uint32_t maxSubsampledArrayLayers; + uint32_t maxDescriptorSetSubsampledSamplers; +} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT; + + + +#define VK_QCOM_rotated_copy_commands 1 +#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 1 +#define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands" +typedef struct VkCopyCommandTransformInfoQCOM { + VkStructureType sType; + const void* pNext; + VkSurfaceTransformFlagBitsKHR transform; +} VkCopyCommandTransformInfoQCOM; + + + +#define VK_EXT_image_robustness 1 +#define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1 +#define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness" +typedef VkPhysicalDeviceImageRobustnessFeatures VkPhysicalDeviceImageRobustnessFeaturesEXT; + + + +#define VK_EXT_image_compression_control 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME "VK_EXT_image_compression_control" + +typedef enum VkImageCompressionFlagBitsEXT { + VK_IMAGE_COMPRESSION_DEFAULT_EXT = 0, + VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT = 0x00000001, + VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT = 0x00000002, + VK_IMAGE_COMPRESSION_DISABLED_EXT = 0x00000004, + VK_IMAGE_COMPRESSION_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkImageCompressionFlagBitsEXT; +typedef VkFlags VkImageCompressionFlagsEXT; + +typedef enum VkImageCompressionFixedRateFlagBitsEXT { + VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT = 0, + VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT = 0x00000001, + VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT = 0x00000002, + VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT = 0x00000004, + VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT = 0x00000008, + VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT = 0x00000010, + VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT = 0x00000020, + VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT = 0x00000040, + VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT = 0x00000080, + VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT = 0x00000100, + VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT = 0x00000200, + VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT = 0x00000400, + VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT = 0x00000800, + VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT = 0x00001000, + VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT = 0x00002000, + VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT = 0x00004000, + VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT = 0x00008000, + VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT = 0x00010000, + VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT = 0x00020000, + VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT = 0x00040000, + VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT = 0x00080000, + VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT = 0x00100000, + VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT = 0x00200000, + VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT = 0x00400000, + VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT = 0x00800000, + VK_IMAGE_COMPRESSION_FIXED_RATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkImageCompressionFixedRateFlagBitsEXT; +typedef VkFlags VkImageCompressionFixedRateFlagsEXT; +typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageCompressionControl; +} VkPhysicalDeviceImageCompressionControlFeaturesEXT; + +typedef struct VkImageCompressionControlEXT { + VkStructureType sType; + const void* pNext; + VkImageCompressionFlagsEXT flags; + uint32_t compressionControlPlaneCount; + VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags; +} VkImageCompressionControlEXT; + +typedef struct VkSubresourceLayout2EXT { + VkStructureType sType; + void* pNext; + VkSubresourceLayout subresourceLayout; +} VkSubresourceLayout2EXT; + +typedef struct VkImageSubresource2EXT { + VkStructureType sType; + void* pNext; + VkImageSubresource imageSubresource; +} VkImageSubresource2EXT; + +typedef struct VkImageCompressionPropertiesEXT { + VkStructureType sType; + void* pNext; + VkImageCompressionFlagsEXT imageCompressionFlags; + VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags; +} VkImageCompressionPropertiesEXT; + +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT( + VkDevice device, + VkImage image, + const VkImageSubresource2EXT* pSubresource, + VkSubresourceLayout2EXT* pLayout); +#endif + + +#define VK_EXT_attachment_feedback_loop_layout 1 +#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION 2 +#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME "VK_EXT_attachment_feedback_loop_layout" +typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 attachmentFeedbackLoopLayout; +} VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + + + +#define VK_EXT_4444_formats 1 +#define VK_EXT_4444_FORMATS_SPEC_VERSION 1 +#define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats" +typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 formatA4R4G4B4; + VkBool32 formatA4B4G4R4; +} VkPhysicalDevice4444FormatsFeaturesEXT; + + + +#define VK_EXT_device_fault 1 +#define VK_EXT_DEVICE_FAULT_SPEC_VERSION 2 +#define VK_EXT_DEVICE_FAULT_EXTENSION_NAME "VK_EXT_device_fault" + +typedef enum VkDeviceFaultAddressTypeEXT { + VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0, + VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1, + VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2, + VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6, + VK_DEVICE_FAULT_ADDRESS_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceFaultAddressTypeEXT; + +typedef enum VkDeviceFaultVendorBinaryHeaderVersionEXT { + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = 1, + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceFaultVendorBinaryHeaderVersionEXT; +typedef struct VkPhysicalDeviceFaultFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 deviceFault; + VkBool32 deviceFaultVendorBinary; +} VkPhysicalDeviceFaultFeaturesEXT; + +typedef struct VkDeviceFaultCountsEXT { + VkStructureType sType; + void* pNext; + uint32_t addressInfoCount; + uint32_t vendorInfoCount; + VkDeviceSize vendorBinarySize; +} VkDeviceFaultCountsEXT; + +typedef struct VkDeviceFaultAddressInfoEXT { + VkDeviceFaultAddressTypeEXT addressType; + VkDeviceAddress reportedAddress; + VkDeviceSize addressPrecision; +} VkDeviceFaultAddressInfoEXT; + +typedef struct VkDeviceFaultVendorInfoEXT { + char description[VK_MAX_DESCRIPTION_SIZE]; + uint64_t vendorFaultCode; + uint64_t vendorFaultData; +} VkDeviceFaultVendorInfoEXT; + +typedef struct VkDeviceFaultInfoEXT { + VkStructureType sType; + void* pNext; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkDeviceFaultAddressInfoEXT* pAddressInfos; + VkDeviceFaultVendorInfoEXT* pVendorInfos; + void* pVendorBinaryData; +} VkDeviceFaultInfoEXT; + +typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT { + uint32_t headerSize; + VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint32_t driverVersion; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + uint32_t applicationNameOffset; + uint32_t applicationVersion; + uint32_t engineNameOffset; + uint32_t engineVersion; + uint32_t apiVersion; +} VkDeviceFaultVendorBinaryHeaderVersionOneEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT( + VkDevice device, + VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo); +#endif + + +#define VK_ARM_rasterization_order_attachment_access 1 +#define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1 +#define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_ARM_rasterization_order_attachment_access" +typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 rasterizationOrderColorAttachmentAccess; + VkBool32 rasterizationOrderDepthAttachmentAccess; + VkBool32 rasterizationOrderStencilAttachmentAccess; +} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + +typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; + + + +#define VK_EXT_rgba10x6_formats 1 +#define VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION 1 +#define VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME "VK_EXT_rgba10x6_formats" +typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 formatRgba10x6WithoutYCbCrSampler; +} VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT; + + + +#define VK_VALVE_mutable_descriptor_type 1 +#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1 +#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type" +typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 mutableDescriptorType; +} VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT; + +typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + +typedef struct VkMutableDescriptorTypeListEXT { + uint32_t descriptorTypeCount; + const VkDescriptorType* pDescriptorTypes; +} VkMutableDescriptorTypeListEXT; + +typedef VkMutableDescriptorTypeListEXT VkMutableDescriptorTypeListVALVE; + +typedef struct VkMutableDescriptorTypeCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t mutableDescriptorTypeListCount; + const VkMutableDescriptorTypeListEXT* pMutableDescriptorTypeLists; +} VkMutableDescriptorTypeCreateInfoEXT; + +typedef VkMutableDescriptorTypeCreateInfoEXT VkMutableDescriptorTypeCreateInfoVALVE; + + + +#define VK_EXT_vertex_input_dynamic_state 1 +#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2 +#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state" +typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexInputDynamicState; +} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; + +typedef struct VkVertexInputBindingDescription2EXT { + VkStructureType sType; + void* pNext; + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; + uint32_t divisor; +} VkVertexInputBindingDescription2EXT; + +typedef struct VkVertexInputAttributeDescription2EXT { + VkStructureType sType; + void* pNext; + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription2EXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT( + VkCommandBuffer commandBuffer, + uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); +#endif + + +#define VK_EXT_physical_device_drm 1 +#define VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION 1 +#define VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME "VK_EXT_physical_device_drm" +typedef struct VkPhysicalDeviceDrmPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 hasPrimary; + VkBool32 hasRender; + int64_t primaryMajor; + int64_t primaryMinor; + int64_t renderMajor; + int64_t renderMinor; +} VkPhysicalDeviceDrmPropertiesEXT; + + + +#define VK_EXT_device_address_binding_report 1 +#define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION 1 +#define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME "VK_EXT_device_address_binding_report" + +typedef enum VkDeviceAddressBindingTypeEXT { + VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT = 0, + VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT = 1, + VK_DEVICE_ADDRESS_BINDING_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceAddressBindingTypeEXT; + +typedef enum VkDeviceAddressBindingFlagBitsEXT { + VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT = 0x00000001, + VK_DEVICE_ADDRESS_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceAddressBindingFlagBitsEXT; +typedef VkFlags VkDeviceAddressBindingFlagsEXT; +typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 reportAddressBinding; +} VkPhysicalDeviceAddressBindingReportFeaturesEXT; + +typedef struct VkDeviceAddressBindingCallbackDataEXT { + VkStructureType sType; + void* pNext; + VkDeviceAddressBindingFlagsEXT flags; + VkDeviceAddress baseAddress; + VkDeviceSize size; + VkDeviceAddressBindingTypeEXT bindingType; +} VkDeviceAddressBindingCallbackDataEXT; + + + +#define VK_EXT_depth_clip_control 1 +#define VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clip_control" +typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClipControl; +} VkPhysicalDeviceDepthClipControlFeaturesEXT; + +typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 negativeOneToOne; +} VkPipelineViewportDepthClipControlCreateInfoEXT; + + + +#define VK_EXT_primitive_topology_list_restart 1 +#define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION 1 +#define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME "VK_EXT_primitive_topology_list_restart" +typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 primitiveTopologyListRestart; + VkBool32 primitiveTopologyPatchListRestart; +} VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + + + +#define VK_HUAWEI_subpass_shading 1 +#define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 2 +#define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading" +typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI { + VkStructureType sType; + void* pNext; + VkRenderPass renderPass; + uint32_t subpass; +} VkSubpassShadingPipelineCreateInfoHUAWEI; + +typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 subpassShading; +} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI; + +typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI { + VkStructureType sType; + void* pNext; + uint32_t maxSubpassShadingWorkgroupSizeAspectRatio; +} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI; + +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize); +typedef void (VKAPI_PTR *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( + VkDevice device, + VkRenderPass renderpass, + VkExtent2D* pMaxWorkgroupSize); + +VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI( + VkCommandBuffer commandBuffer); +#endif + + +#define VK_HUAWEI_invocation_mask 1 +#define VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION 1 +#define VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME "VK_HUAWEI_invocation_mask" +typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 invocationMask; +} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI; + +typedef void (VKAPI_PTR *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout); +#endif + + +#define VK_NV_external_memory_rdma 1 +typedef void* VkRemoteAddressNV; +#define VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME "VK_NV_external_memory_rdma" +typedef struct VkMemoryGetRemoteAddressInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetRemoteAddressInfoNV; + +typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 externalMemoryRDMA; +} VkPhysicalDeviceExternalMemoryRDMAFeaturesNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV( + VkDevice device, + const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, + VkRemoteAddressNV* pAddress); +#endif + + +#define VK_EXT_pipeline_properties 1 +#define VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME "VK_EXT_pipeline_properties" +typedef VkPipelineInfoKHR VkPipelineInfoEXT; + +typedef struct VkPipelinePropertiesIdentifierEXT { + VkStructureType sType; + void* pNext; + uint8_t pipelineIdentifier[VK_UUID_SIZE]; +} VkPipelinePropertiesIdentifierEXT; + +typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelinePropertiesIdentifier; +} VkPhysicalDevicePipelinePropertiesFeaturesEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT( + VkDevice device, + const VkPipelineInfoEXT* pPipelineInfo, + VkBaseOutStructure* pPipelineProperties); +#endif + + +#define VK_EXT_multisampled_render_to_single_sampled 1 +#define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION 1 +#define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME "VK_EXT_multisampled_render_to_single_sampled" +typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 multisampledRenderToSingleSampled; +} VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + +typedef struct VkSubpassResolvePerformanceQueryEXT { + VkStructureType sType; + void* pNext; + VkBool32 optimal; +} VkSubpassResolvePerformanceQueryEXT; + +typedef struct VkMultisampledRenderToSingleSampledInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 multisampledRenderToSingleSampledEnable; + VkSampleCountFlagBits rasterizationSamples; +} VkMultisampledRenderToSingleSampledInfoEXT; + + + +#define VK_EXT_extended_dynamic_state2 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2" +typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState2; + VkBool32 extendedDynamicState2LogicOp; + VkBool32 extendedDynamicState2PatchControlPoints; +} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT( + VkCommandBuffer commandBuffer, + uint32_t patchControlPoints); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT( + VkCommandBuffer commandBuffer, + VkLogicOp logicOp); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable); +#endif + + +#define VK_EXT_color_write_enable 1 +#define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1 +#define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable" +typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 colorWriteEnable; +} VkPhysicalDeviceColorWriteEnableFeaturesEXT; + +typedef struct VkPipelineColorWriteCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkBool32* pColorWriteEnables; +} VkPipelineColorWriteCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkBool32* pColorWriteEnables); +#endif + + +#define VK_EXT_primitives_generated_query 1 +#define VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION 1 +#define VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME "VK_EXT_primitives_generated_query" +typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 primitivesGeneratedQuery; + VkBool32 primitivesGeneratedQueryWithRasterizerDiscard; + VkBool32 primitivesGeneratedQueryWithNonZeroStreams; +} VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; + + + +#define VK_EXT_global_priority_query 1 +#define VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION 1 +#define VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME "VK_EXT_global_priority_query" +#define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT VK_MAX_GLOBAL_PRIORITY_SIZE_KHR +typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT; + +typedef VkQueueFamilyGlobalPriorityPropertiesKHR VkQueueFamilyGlobalPriorityPropertiesEXT; + + + +#define VK_EXT_image_view_min_lod 1 +#define VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION 1 +#define VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME "VK_EXT_image_view_min_lod" +typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 minLod; +} VkPhysicalDeviceImageViewMinLodFeaturesEXT; + +typedef struct VkImageViewMinLodCreateInfoEXT { + VkStructureType sType; + const void* pNext; + float minLod; +} VkImageViewMinLodCreateInfoEXT; + + + +#define VK_EXT_multi_draw 1 +#define VK_EXT_MULTI_DRAW_SPEC_VERSION 1 +#define VK_EXT_MULTI_DRAW_EXTENSION_NAME "VK_EXT_multi_draw" +typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 multiDraw; +} VkPhysicalDeviceMultiDrawFeaturesEXT; + +typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxMultiDrawCount; +} VkPhysicalDeviceMultiDrawPropertiesEXT; + +typedef struct VkMultiDrawInfoEXT { + uint32_t firstVertex; + uint32_t vertexCount; +} VkMultiDrawInfoEXT; + +typedef struct VkMultiDrawIndexedInfoEXT { + uint32_t firstIndex; + uint32_t indexCount; + int32_t vertexOffset; +} VkMultiDrawIndexedInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawInfoEXT* pVertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawIndexedInfoEXT* pIndexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + const int32_t* pVertexOffset); +#endif + + +#define VK_EXT_image_2d_view_of_3d 1 +#define VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION 1 +#define VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_2d_view_of_3d" +typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 image2DViewOf3D; + VkBool32 sampler2DViewOf3D; +} VkPhysicalDeviceImage2DViewOf3DFeaturesEXT; + + + +#define VK_EXT_shader_tile_image 1 +#define VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION 1 +#define VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME "VK_EXT_shader_tile_image" +typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderTileImageColorReadAccess; + VkBool32 shaderTileImageDepthReadAccess; + VkBool32 shaderTileImageStencilReadAccess; +} VkPhysicalDeviceShaderTileImageFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderTileImageCoherentReadAccelerated; + VkBool32 shaderTileImageReadSampleFromPixelRateInvocation; + VkBool32 shaderTileImageReadFromHelperInvocation; +} VkPhysicalDeviceShaderTileImagePropertiesEXT; + + + +#define VK_EXT_opacity_micromap 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkMicromapEXT) +#define VK_EXT_OPACITY_MICROMAP_SPEC_VERSION 2 +#define VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME "VK_EXT_opacity_micromap" + +typedef enum VkMicromapTypeEXT { + VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT = 0, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV = 1000397000, +#endif + VK_MICROMAP_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkMicromapTypeEXT; + +typedef enum VkBuildMicromapModeEXT { + VK_BUILD_MICROMAP_MODE_BUILD_EXT = 0, + VK_BUILD_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBuildMicromapModeEXT; + +typedef enum VkCopyMicromapModeEXT { + VK_COPY_MICROMAP_MODE_CLONE_EXT = 0, + VK_COPY_MICROMAP_MODE_SERIALIZE_EXT = 1, + VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT = 2, + VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3, + VK_COPY_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkCopyMicromapModeEXT; + +typedef enum VkOpacityMicromapFormatEXT { + VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1, + VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2, + VK_OPACITY_MICROMAP_FORMAT_MAX_ENUM_EXT = 0x7FFFFFFF +} VkOpacityMicromapFormatEXT; + +typedef enum VkOpacityMicromapSpecialIndexEXT { + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_MAX_ENUM_EXT = 0x7FFFFFFF +} VkOpacityMicromapSpecialIndexEXT; + +typedef enum VkAccelerationStructureCompatibilityKHR { + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0, + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1, + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureCompatibilityKHR; + +typedef enum VkAccelerationStructureBuildTypeKHR { + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureBuildTypeKHR; + +typedef enum VkBuildMicromapFlagBitsEXT { + VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT = 0x00000001, + VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT = 0x00000002, + VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT = 0x00000004, + VK_BUILD_MICROMAP_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBuildMicromapFlagBitsEXT; +typedef VkFlags VkBuildMicromapFlagsEXT; + +typedef enum VkMicromapCreateFlagBitsEXT { + VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000001, + VK_MICROMAP_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkMicromapCreateFlagBitsEXT; +typedef VkFlags VkMicromapCreateFlagsEXT; +typedef struct VkMicromapUsageEXT { + uint32_t count; + uint32_t subdivisionLevel; + uint32_t format; +} VkMicromapUsageEXT; + +typedef union VkDeviceOrHostAddressKHR { + VkDeviceAddress deviceAddress; + void* hostAddress; +} VkDeviceOrHostAddressKHR; + +typedef struct VkMicromapBuildInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapTypeEXT type; + VkBuildMicromapFlagsEXT flags; + VkBuildMicromapModeEXT mode; + VkMicromapEXT dstMicromap; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts; + const VkMicromapUsageEXT* const* ppUsageCounts; + VkDeviceOrHostAddressConstKHR data; + VkDeviceOrHostAddressKHR scratchData; + VkDeviceOrHostAddressConstKHR triangleArray; + VkDeviceSize triangleArrayStride; +} VkMicromapBuildInfoEXT; + +typedef struct VkMicromapCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapCreateFlagsEXT createFlags; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; + VkMicromapTypeEXT type; + VkDeviceAddress deviceAddress; +} VkMicromapCreateInfoEXT; + +typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 micromap; + VkBool32 micromapCaptureReplay; + VkBool32 micromapHostCommands; +} VkPhysicalDeviceOpacityMicromapFeaturesEXT; + +typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxOpacity2StateSubdivisionLevel; + uint32_t maxOpacity4StateSubdivisionLevel; +} VkPhysicalDeviceOpacityMicromapPropertiesEXT; + +typedef struct VkMicromapVersionInfoEXT { + VkStructureType sType; + const void* pNext; + const uint8_t* pVersionData; +} VkMicromapVersionInfoEXT; + +typedef struct VkCopyMicromapToMemoryInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapEXT src; + VkDeviceOrHostAddressKHR dst; + VkCopyMicromapModeEXT mode; +} VkCopyMicromapToMemoryInfoEXT; + +typedef struct VkCopyMemoryToMicromapInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR src; + VkMicromapEXT dst; + VkCopyMicromapModeEXT mode; +} VkCopyMemoryToMicromapInfoEXT; + +typedef struct VkCopyMicromapInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapEXT src; + VkMicromapEXT dst; + VkCopyMicromapModeEXT mode; +} VkCopyMicromapInfoEXT; + +typedef struct VkMicromapBuildSizesInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceSize micromapSize; + VkDeviceSize buildScratchSize; + VkBool32 discardable; +} VkMicromapBuildSizesInfoEXT; + +typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT { + VkStructureType sType; + void* pNext; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts; + const VkMicromapUsageEXT* const* ppUsageCounts; + VkMicromapEXT micromap; +} VkAccelerationStructureTrianglesOpacityMicromapEXT; + +typedef struct VkMicromapTriangleEXT { + uint32_t dataOffset; + uint16_t subdivisionLevel; + uint16_t format; +} VkMicromapTriangleEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); +typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMicromapEXT( + VkDevice device, + const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkMicromapEXT* pMicromap); + +VKAPI_ATTR void VKAPI_CALL vkDestroyMicromapEXT( + VkDevice device, + VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT( + VkDevice device, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapInfoEXT* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT( + VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT( + VkDevice device, + const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); + +VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo); +#endif + + +#define VK_EXT_load_store_op_none 1 +#define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1 +#define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none" + + +#define VK_HUAWEI_cluster_culling_shader 1 +#define VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION 2 +#define VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME "VK_HUAWEI_cluster_culling_shader" +typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 clustercullingShader; + VkBool32 multiviewClusterCullingShader; +} VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI; + +typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI { + VkStructureType sType; + void* pNext; + uint32_t maxWorkGroupCount[3]; + uint32_t maxWorkGroupSize[3]; + uint32_t maxOutputClusterCount; + VkDeviceSize indirectBufferOffsetAlignment; +} VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterHUAWEI)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterIndirectHUAWEI)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterHUAWEI( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterIndirectHUAWEI( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); +#endif + + +#define VK_EXT_border_color_swizzle 1 +#define VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION 1 +#define VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME "VK_EXT_border_color_swizzle" +typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 borderColorSwizzle; + VkBool32 borderColorSwizzleFromImage; +} VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; + +typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkComponentMapping components; + VkBool32 srgb; +} VkSamplerBorderColorComponentMappingCreateInfoEXT; + + + +#define VK_EXT_pageable_device_local_memory 1 +#define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION 1 +#define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME "VK_EXT_pageable_device_local_memory" +typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pageableDeviceLocalMemory; +} VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT( + VkDevice device, + VkDeviceMemory memory, + float priority); +#endif + + +#define VK_ARM_shader_core_properties 1 +#define VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION 1 +#define VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_ARM_shader_core_properties" +typedef struct VkPhysicalDeviceShaderCorePropertiesARM { + VkStructureType sType; + void* pNext; + uint32_t pixelRate; + uint32_t texelRate; + uint32_t fmaRate; +} VkPhysicalDeviceShaderCorePropertiesARM; + + + +#define VK_EXT_image_sliced_view_of_3d 1 +#define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION 1 +#define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_sliced_view_of_3d" +#define VK_REMAINING_3D_SLICES_EXT (~0U) +typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageSlicedViewOf3D; +} VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT; + +typedef struct VkImageViewSlicedCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t sliceOffset; + uint32_t sliceCount; +} VkImageViewSlicedCreateInfoEXT; + + + +#define VK_VALVE_descriptor_set_host_mapping 1 +#define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION 1 +#define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME "VK_VALVE_descriptor_set_host_mapping" +typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + VkStructureType sType; + void* pNext; + VkBool32 descriptorSetHostMapping; +} VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + +typedef struct VkDescriptorSetBindingReferenceVALVE { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayout descriptorSetLayout; + uint32_t binding; +} VkDescriptorSetBindingReferenceVALVE; + +typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE { + VkStructureType sType; + void* pNext; + size_t descriptorOffset; + uint32_t descriptorSize; +} VkDescriptorSetLayoutHostMappingInfoVALVE; + +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void** ppData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE( + VkDevice device, + const VkDescriptorSetBindingReferenceVALVE* pBindingReference, + VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE( + VkDevice device, + VkDescriptorSet descriptorSet, + void** ppData); +#endif + + +#define VK_EXT_depth_clamp_zero_one 1 +#define VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_EXT_depth_clamp_zero_one" +typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClampZeroOne; +} VkPhysicalDeviceDepthClampZeroOneFeaturesEXT; + + + +#define VK_EXT_non_seamless_cube_map 1 +#define VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION 1 +#define VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME "VK_EXT_non_seamless_cube_map" +typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 nonSeamlessCubeMap; +} VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + + + +#define VK_QCOM_fragment_density_map_offset 1 +#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1 +#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset" +typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMapOffset; +} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + +typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + VkStructureType sType; + void* pNext; + VkExtent2D fragmentDensityOffsetGranularity; +} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + +typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM { + VkStructureType sType; + const void* pNext; + uint32_t fragmentDensityOffsetCount; + const VkOffset2D* pFragmentDensityOffsets; +} VkSubpassFragmentDensityMapOffsetEndInfoQCOM; + + + +#define VK_NV_copy_memory_indirect 1 +#define VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION 1 +#define VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_NV_copy_memory_indirect" +typedef struct VkCopyMemoryIndirectCommandNV { + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize size; +} VkCopyMemoryIndirectCommandNV; + +typedef struct VkCopyMemoryToImageIndirectCommandNV { + VkDeviceAddress srcAddress; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkCopyMemoryToImageIndirectCommandNV; + +typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 indirectCopy; +} VkPhysicalDeviceCopyMemoryIndirectFeaturesNV; + +typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV { + VkStructureType sType; + void* pNext; + VkQueueFlags supportedQueues; +} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV; + +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + VkImage dstImage, + VkImageLayout dstImageLayout, + const VkImageSubresourceLayers* pImageSubresources); +#endif + + +#define VK_NV_memory_decompression 1 +#define VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION 1 +#define VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME "VK_NV_memory_decompression" + +// Flag bits for VkMemoryDecompressionMethodFlagBitsNV +typedef VkFlags64 VkMemoryDecompressionMethodFlagBitsNV; +static const VkMemoryDecompressionMethodFlagBitsNV VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV = 0x00000001ULL; + +typedef VkFlags64 VkMemoryDecompressionMethodFlagsNV; +typedef struct VkDecompressMemoryRegionNV { + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize compressedSize; + VkDeviceSize decompressedSize; + VkMemoryDecompressionMethodFlagsNV decompressionMethod; +} VkDecompressMemoryRegionNV; + +typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 memoryDecompression; +} VkPhysicalDeviceMemoryDecompressionFeaturesNV; + +typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV { + VkStructureType sType; + void* pNext; + VkMemoryDecompressionMethodFlagsNV decompressionMethods; + uint64_t maxDecompressionIndirectCount; +} VkPhysicalDeviceMemoryDecompressionPropertiesNV; + +typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); +typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryIndirectCountNV)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV( + VkCommandBuffer commandBuffer, + uint32_t decompressRegionCount, + const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t stride); +#endif + + +#define VK_NV_linear_color_attachment 1 +#define VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION 1 +#define VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME "VK_NV_linear_color_attachment" +typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 linearColorAttachment; +} VkPhysicalDeviceLinearColorAttachmentFeaturesNV; + + + +#define VK_GOOGLE_surfaceless_query 1 +#define VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION 2 +#define VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME "VK_GOOGLE_surfaceless_query" + + +#define VK_EXT_image_compression_control_swapchain 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME "VK_EXT_image_compression_control_swapchain" +typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageCompressionControlSwapchain; +} VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + + + +#define VK_QCOM_image_processing 1 +#define VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION 1 +#define VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME "VK_QCOM_image_processing" +typedef struct VkImageViewSampleWeightCreateInfoQCOM { + VkStructureType sType; + const void* pNext; + VkOffset2D filterCenter; + VkExtent2D filterSize; + uint32_t numPhases; +} VkImageViewSampleWeightCreateInfoQCOM; + +typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 textureSampleWeighted; + VkBool32 textureBoxFilter; + VkBool32 textureBlockMatch; +} VkPhysicalDeviceImageProcessingFeaturesQCOM; + +typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM { + VkStructureType sType; + void* pNext; + uint32_t maxWeightFilterPhases; + VkExtent2D maxWeightFilterDimension; + VkExtent2D maxBlockMatchRegion; + VkExtent2D maxBoxFilterBlockSize; +} VkPhysicalDeviceImageProcessingPropertiesQCOM; + + + +#define VK_EXT_extended_dynamic_state3 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION 2 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME "VK_EXT_extended_dynamic_state3" +typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState3TessellationDomainOrigin; + VkBool32 extendedDynamicState3DepthClampEnable; + VkBool32 extendedDynamicState3PolygonMode; + VkBool32 extendedDynamicState3RasterizationSamples; + VkBool32 extendedDynamicState3SampleMask; + VkBool32 extendedDynamicState3AlphaToCoverageEnable; + VkBool32 extendedDynamicState3AlphaToOneEnable; + VkBool32 extendedDynamicState3LogicOpEnable; + VkBool32 extendedDynamicState3ColorBlendEnable; + VkBool32 extendedDynamicState3ColorBlendEquation; + VkBool32 extendedDynamicState3ColorWriteMask; + VkBool32 extendedDynamicState3RasterizationStream; + VkBool32 extendedDynamicState3ConservativeRasterizationMode; + VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize; + VkBool32 extendedDynamicState3DepthClipEnable; + VkBool32 extendedDynamicState3SampleLocationsEnable; + VkBool32 extendedDynamicState3ColorBlendAdvanced; + VkBool32 extendedDynamicState3ProvokingVertexMode; + VkBool32 extendedDynamicState3LineRasterizationMode; + VkBool32 extendedDynamicState3LineStippleEnable; + VkBool32 extendedDynamicState3DepthClipNegativeOneToOne; + VkBool32 extendedDynamicState3ViewportWScalingEnable; + VkBool32 extendedDynamicState3ViewportSwizzle; + VkBool32 extendedDynamicState3CoverageToColorEnable; + VkBool32 extendedDynamicState3CoverageToColorLocation; + VkBool32 extendedDynamicState3CoverageModulationMode; + VkBool32 extendedDynamicState3CoverageModulationTableEnable; + VkBool32 extendedDynamicState3CoverageModulationTable; + VkBool32 extendedDynamicState3CoverageReductionMode; + VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable; + VkBool32 extendedDynamicState3ShadingRateImageEnable; +} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT; + +typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 dynamicPrimitiveTopologyUnrestricted; +} VkPhysicalDeviceExtendedDynamicState3PropertiesEXT; + +typedef struct VkColorBlendEquationEXT { + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; +} VkColorBlendEquationEXT; + +typedef struct VkColorBlendAdvancedEXT { + VkBlendOp advancedBlendOp; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; + VkBool32 clampResults; +} VkColorBlendAdvancedEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream); +typedef void (VKAPI_PTR *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced); +typedef void (VKAPI_PTR *PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable); +typedef void (VKAPI_PTR *PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT( + VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClampEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT( + VkCommandBuffer commandBuffer, + VkPolygonMode polygonMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToCoverageEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToOneEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 logicOpEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32* pColorBlendEnables); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags* pColorWriteMasks); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT( + VkCommandBuffer commandBuffer, + uint32_t rasterizationStream); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkConservativeRasterizationModeEXT conservativeRasterizationMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT( + VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClipEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 sampleLocationsEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT( + VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stippledLineEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT( + VkCommandBuffer commandBuffer, + VkBool32 negativeOneToOne); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 viewportWScalingEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV* pViewportSwizzles); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageToColorEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV( + VkCommandBuffer commandBuffer, + uint32_t coverageToColorLocation); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV( + VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV( + VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 shadingRateImageEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV( + VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode); +#endif + + +#define VK_EXT_subpass_merge_feedback 1 +#define VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION 2 +#define VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME "VK_EXT_subpass_merge_feedback" + +typedef enum VkSubpassMergeStatusEXT { + VK_SUBPASS_MERGE_STATUS_MERGED_EXT = 0, + VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT = 1, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT = 2, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT = 3, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT = 4, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT = 5, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT = 6, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT = 7, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT = 8, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT = 9, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT = 10, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT = 11, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT = 12, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT = 13, + VK_SUBPASS_MERGE_STATUS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSubpassMergeStatusEXT; +typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 subpassMergeFeedback; +} VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + +typedef struct VkRenderPassCreationControlEXT { + VkStructureType sType; + const void* pNext; + VkBool32 disallowMerging; +} VkRenderPassCreationControlEXT; + +typedef struct VkRenderPassCreationFeedbackInfoEXT { + uint32_t postMergeSubpassCount; +} VkRenderPassCreationFeedbackInfoEXT; + +typedef struct VkRenderPassCreationFeedbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback; +} VkRenderPassCreationFeedbackCreateInfoEXT; + +typedef struct VkRenderPassSubpassFeedbackInfoEXT { + VkSubpassMergeStatusEXT subpassMergeStatus; + char description[VK_MAX_DESCRIPTION_SIZE]; + uint32_t postMergeIndex; +} VkRenderPassSubpassFeedbackInfoEXT; + +typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback; +} VkRenderPassSubpassFeedbackCreateInfoEXT; + + + +#define VK_LUNARG_direct_driver_loading 1 +#define VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION 1 +#define VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME "VK_LUNARG_direct_driver_loading" + +typedef enum VkDirectDriverLoadingModeLUNARG { + VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG = 0, + VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG = 1, + VK_DIRECT_DRIVER_LOADING_MODE_MAX_ENUM_LUNARG = 0x7FFFFFFF +} VkDirectDriverLoadingModeLUNARG; +typedef VkFlags VkDirectDriverLoadingFlagsLUNARG; +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddrLUNARG)( + VkInstance instance, const char* pName); + +typedef struct VkDirectDriverLoadingInfoLUNARG { + VkStructureType sType; + void* pNext; + VkDirectDriverLoadingFlagsLUNARG flags; + PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr; +} VkDirectDriverLoadingInfoLUNARG; + +typedef struct VkDirectDriverLoadingListLUNARG { + VkStructureType sType; + void* pNext; + VkDirectDriverLoadingModeLUNARG mode; + uint32_t driverCount; + const VkDirectDriverLoadingInfoLUNARG* pDrivers; +} VkDirectDriverLoadingListLUNARG; + + + +#define VK_EXT_shader_module_identifier 1 +#define VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT 32U +#define VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION 1 +#define VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME "VK_EXT_shader_module_identifier" +typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderModuleIdentifier; +} VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE]; +} VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT; + +typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t identifierSize; + const uint8_t* pIdentifier; +} VkPipelineShaderStageModuleIdentifierCreateInfoEXT; + +typedef struct VkShaderModuleIdentifierEXT { + VkStructureType sType; + void* pNext; + uint32_t identifierSize; + uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]; +} VkShaderModuleIdentifierEXT; + +typedef void (VKAPI_PTR *PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier); +typedef void (VKAPI_PTR *PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT( + VkDevice device, + VkShaderModule shaderModule, + VkShaderModuleIdentifierEXT* pIdentifier); + +VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModuleIdentifierEXT* pIdentifier); +#endif + + +#define VK_EXT_rasterization_order_attachment_access 1 +#define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1 +#define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_EXT_rasterization_order_attachment_access" + + +#define VK_NV_optical_flow 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkOpticalFlowSessionNV) +#define VK_NV_OPTICAL_FLOW_SPEC_VERSION 1 +#define VK_NV_OPTICAL_FLOW_EXTENSION_NAME "VK_NV_optical_flow" + +typedef enum VkOpticalFlowPerformanceLevelNV { + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV = 1, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV = 2, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV = 3, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowPerformanceLevelNV; + +typedef enum VkOpticalFlowSessionBindingPointNV { + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV = 1, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV = 2, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV = 3, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV = 4, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV = 5, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV = 6, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV = 7, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV = 8, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowSessionBindingPointNV; + +typedef enum VkOpticalFlowGridSizeFlagBitsNV { + VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_GRID_SIZE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowGridSizeFlagBitsNV; +typedef VkFlags VkOpticalFlowGridSizeFlagsNV; + +typedef enum VkOpticalFlowUsageFlagBitsNV { + VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_USAGE_COST_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV = 0x00000010, + VK_OPTICAL_FLOW_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowUsageFlagBitsNV; +typedef VkFlags VkOpticalFlowUsageFlagsNV; + +typedef enum VkOpticalFlowSessionCreateFlagBitsNV { + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV = 0x00000010, + VK_OPTICAL_FLOW_SESSION_CREATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowSessionCreateFlagBitsNV; +typedef VkFlags VkOpticalFlowSessionCreateFlagsNV; + +typedef enum VkOpticalFlowExecuteFlagBitsNV { + VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_EXECUTE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowExecuteFlagBitsNV; +typedef VkFlags VkOpticalFlowExecuteFlagsNV; +typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 opticalFlow; +} VkPhysicalDeviceOpticalFlowFeaturesNV; + +typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV { + VkStructureType sType; + void* pNext; + VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes; + VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes; + VkBool32 hintSupported; + VkBool32 costSupported; + VkBool32 bidirectionalFlowSupported; + VkBool32 globalFlowSupported; + uint32_t minWidth; + uint32_t minHeight; + uint32_t maxWidth; + uint32_t maxHeight; + uint32_t maxNumRegionsOfInterest; +} VkPhysicalDeviceOpticalFlowPropertiesNV; + +typedef struct VkOpticalFlowImageFormatInfoNV { + VkStructureType sType; + const void* pNext; + VkOpticalFlowUsageFlagsNV usage; +} VkOpticalFlowImageFormatInfoNV; + +typedef struct VkOpticalFlowImageFormatPropertiesNV { + VkStructureType sType; + const void* pNext; + VkFormat format; +} VkOpticalFlowImageFormatPropertiesNV; + +typedef struct VkOpticalFlowSessionCreateInfoNV { + VkStructureType sType; + void* pNext; + uint32_t width; + uint32_t height; + VkFormat imageFormat; + VkFormat flowVectorFormat; + VkFormat costFormat; + VkOpticalFlowGridSizeFlagsNV outputGridSize; + VkOpticalFlowGridSizeFlagsNV hintGridSize; + VkOpticalFlowPerformanceLevelNV performanceLevel; + VkOpticalFlowSessionCreateFlagsNV flags; +} VkOpticalFlowSessionCreateInfoNV; + +typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV { + VkStructureType sType; + void* pNext; + uint32_t id; + uint32_t size; + const void* pPrivateData; +} VkOpticalFlowSessionCreatePrivateDataInfoNV; + +typedef struct VkOpticalFlowExecuteInfoNV { + VkStructureType sType; + void* pNext; + VkOpticalFlowExecuteFlagsNV flags; + uint32_t regionCount; + const VkRect2D* pRegions; +} VkOpticalFlowExecuteInfoNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession); +typedef void (VKAPI_PTR *PFN_vkDestroyOpticalFlowSessionNV)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkBindOpticalFlowSessionImageNV)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout); +typedef void (VKAPI_PTR *PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV( + VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession); + +VKAPI_ATTR void VKAPI_CALL vkDestroyOpticalFlowSessionNV( + VkDevice device, + VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV( + VkDevice device, + VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout); + +VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV( + VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo); +#endif + + +#define VK_EXT_legacy_dithering 1 +#define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 1 +#define VK_EXT_LEGACY_DITHERING_EXTENSION_NAME "VK_EXT_legacy_dithering" +typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 legacyDithering; +} VkPhysicalDeviceLegacyDitheringFeaturesEXT; + + + +#define VK_EXT_pipeline_protected_access 1 +#define VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME "VK_EXT_pipeline_protected_access" +typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelineProtectedAccess; +} VkPhysicalDevicePipelineProtectedAccessFeaturesEXT; + + + +#define VK_EXT_shader_object 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderEXT) +#define VK_EXT_SHADER_OBJECT_SPEC_VERSION 1 +#define VK_EXT_SHADER_OBJECT_EXTENSION_NAME "VK_EXT_shader_object" + +typedef enum VkShaderCodeTypeEXT { + VK_SHADER_CODE_TYPE_BINARY_EXT = 0, + VK_SHADER_CODE_TYPE_SPIRV_EXT = 1, + VK_SHADER_CODE_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkShaderCodeTypeEXT; + +typedef enum VkShaderCreateFlagBitsEXT { + VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = 0x00000001, + VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000002, + VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000004, + VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT = 0x00000008, + VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = 0x00000010, + VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, + VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, + VK_SHADER_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkShaderCreateFlagBitsEXT; +typedef VkFlags VkShaderCreateFlagsEXT; +typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderObject; +} VkPhysicalDeviceShaderObjectFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT { + VkStructureType sType; + void* pNext; + uint8_t shaderBinaryUUID[VK_UUID_SIZE]; + uint32_t shaderBinaryVersion; +} VkPhysicalDeviceShaderObjectPropertiesEXT; + +typedef struct VkShaderCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkShaderCreateFlagsEXT flags; + VkShaderStageFlagBits stage; + VkShaderStageFlags nextStage; + VkShaderCodeTypeEXT codeType; + size_t codeSize; + const void* pCode; + const char* pName; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; + const VkSpecializationInfo* pSpecializationInfo; +} VkShaderCreateInfoEXT; + +typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkShaderRequiredSubgroupSizeCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateShadersEXT)(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders); +typedef void (VKAPI_PTR *PFN_vkDestroyShaderEXT)(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetShaderBinaryDataEXT)(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdBindShadersEXT)(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT( + VkDevice device, + uint32_t createInfoCount, + const VkShaderCreateInfoEXT* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkShaderEXT* pShaders); + +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderEXT( + VkDevice device, + VkShaderEXT shader, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderBinaryDataEXT( + VkDevice device, + VkShaderEXT shader, + size_t* pDataSize, + void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindShadersEXT( + VkCommandBuffer commandBuffer, + uint32_t stageCount, + const VkShaderStageFlagBits* pStages, + const VkShaderEXT* pShaders); +#endif + + +#define VK_QCOM_tile_properties 1 +#define VK_QCOM_TILE_PROPERTIES_SPEC_VERSION 1 +#define VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME "VK_QCOM_tile_properties" +typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 tileProperties; +} VkPhysicalDeviceTilePropertiesFeaturesQCOM; + +typedef struct VkTilePropertiesQCOM { + VkStructureType sType; + void* pNext; + VkExtent3D tileSize; + VkExtent2D apronSize; + VkOffset2D origin; +} VkTilePropertiesQCOM; + +typedef VkResult (VKAPI_PTR *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM( + VkDevice device, + VkFramebuffer framebuffer, + uint32_t* pPropertiesCount, + VkTilePropertiesQCOM* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM( + VkDevice device, + const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties); +#endif + + +#define VK_SEC_amigo_profiling 1 +#define VK_SEC_AMIGO_PROFILING_SPEC_VERSION 1 +#define VK_SEC_AMIGO_PROFILING_EXTENSION_NAME "VK_SEC_amigo_profiling" +typedef struct VkPhysicalDeviceAmigoProfilingFeaturesSEC { + VkStructureType sType; + void* pNext; + VkBool32 amigoProfiling; +} VkPhysicalDeviceAmigoProfilingFeaturesSEC; + +typedef struct VkAmigoProfilingSubmitInfoSEC { + VkStructureType sType; + const void* pNext; + uint64_t firstDrawTimestamp; + uint64_t swapBufferTimestamp; +} VkAmigoProfilingSubmitInfoSEC; + + + +#define VK_QCOM_multiview_per_view_viewports 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME "VK_QCOM_multiview_per_view_viewports" +typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 multiviewPerViewViewports; +} VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + + + +#define VK_NV_ray_tracing_invocation_reorder 1 +#define VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 1 +#define VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME "VK_NV_ray_tracing_invocation_reorder" + +typedef enum VkRayTracingInvocationReorderModeNV { + VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = 0, + VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = 1, + VK_RAY_TRACING_INVOCATION_REORDER_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkRayTracingInvocationReorderModeNV; +typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV { + VkStructureType sType; + void* pNext; + VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint; +} VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV; + +typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingInvocationReorder; +} VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV; + + + +#define VK_EXT_mutable_descriptor_type 1 +#define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1 +#define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_EXT_mutable_descriptor_type" + + +#define VK_ARM_shader_core_builtins 1 +#define VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION 2 +#define VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME "VK_ARM_shader_core_builtins" +typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 shaderCoreBuiltins; +} VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM; + +typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM { + VkStructureType sType; + void* pNext; + uint64_t shaderCoreMask; + uint32_t shaderCoreCount; + uint32_t shaderWarpsPerCore; +} VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM; + + + +#define VK_EXT_pipeline_library_group_handles 1 +#define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME "VK_EXT_pipeline_library_group_handles" +typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelineLibraryGroupHandles; +} VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + + + +#define VK_QCOM_multiview_per_view_render_areas 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME "VK_QCOM_multiview_per_view_render_areas" +typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 multiviewPerViewRenderAreas; +} VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + +typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM { + VkStructureType sType; + const void* pNext; + uint32_t perViewRenderAreaCount; + const VkRect2D* pPerViewRenderAreas; +} VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + + + +#define VK_KHR_acceleration_structure 1 +#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 +#define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure" + +typedef enum VkBuildAccelerationStructureModeKHR { + VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0, + VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1, + VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkBuildAccelerationStructureModeKHR; + +typedef enum VkAccelerationStructureCreateFlagBitsKHR { + VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, + VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, + VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, + VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureCreateFlagBitsKHR; +typedef VkFlags VkAccelerationStructureCreateFlagsKHR; +typedef struct VkAccelerationStructureBuildRangeInfoKHR { + uint32_t primitiveCount; + uint32_t primitiveOffset; + uint32_t firstVertex; + uint32_t transformOffset; +} VkAccelerationStructureBuildRangeInfoKHR; + +typedef struct VkAccelerationStructureGeometryTrianglesDataKHR { + VkStructureType sType; + const void* pNext; + VkFormat vertexFormat; + VkDeviceOrHostAddressConstKHR vertexData; + VkDeviceSize vertexStride; + uint32_t maxVertex; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexData; + VkDeviceOrHostAddressConstKHR transformData; +} VkAccelerationStructureGeometryTrianglesDataKHR; + +typedef struct VkAccelerationStructureGeometryAabbsDataKHR { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR data; + VkDeviceSize stride; +} VkAccelerationStructureGeometryAabbsDataKHR; + +typedef struct VkAccelerationStructureGeometryInstancesDataKHR { + VkStructureType sType; + const void* pNext; + VkBool32 arrayOfPointers; + VkDeviceOrHostAddressConstKHR data; +} VkAccelerationStructureGeometryInstancesDataKHR; + +typedef union VkAccelerationStructureGeometryDataKHR { + VkAccelerationStructureGeometryTrianglesDataKHR triangles; + VkAccelerationStructureGeometryAabbsDataKHR aabbs; + VkAccelerationStructureGeometryInstancesDataKHR instances; +} VkAccelerationStructureGeometryDataKHR; + +typedef struct VkAccelerationStructureGeometryKHR { + VkStructureType sType; + const void* pNext; + VkGeometryTypeKHR geometryType; + VkAccelerationStructureGeometryDataKHR geometry; + VkGeometryFlagsKHR flags; +} VkAccelerationStructureGeometryKHR; + +typedef struct VkAccelerationStructureBuildGeometryInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureTypeKHR type; + VkBuildAccelerationStructureFlagsKHR flags; + VkBuildAccelerationStructureModeKHR mode; + VkAccelerationStructureKHR srcAccelerationStructure; + VkAccelerationStructureKHR dstAccelerationStructure; + uint32_t geometryCount; + const VkAccelerationStructureGeometryKHR* pGeometries; + const VkAccelerationStructureGeometryKHR* const* ppGeometries; + VkDeviceOrHostAddressKHR scratchData; +} VkAccelerationStructureBuildGeometryInfoKHR; + +typedef struct VkAccelerationStructureCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureCreateFlagsKHR createFlags; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; + VkAccelerationStructureTypeKHR type; + VkDeviceAddress deviceAddress; +} VkAccelerationStructureCreateInfoKHR; + +typedef struct VkWriteDescriptorSetAccelerationStructureKHR { + VkStructureType sType; + const void* pNext; + uint32_t accelerationStructureCount; + const VkAccelerationStructureKHR* pAccelerationStructures; +} VkWriteDescriptorSetAccelerationStructureKHR; + +typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 accelerationStructure; + VkBool32 accelerationStructureCaptureReplay; + VkBool32 accelerationStructureIndirectBuild; + VkBool32 accelerationStructureHostCommands; + VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind; +} VkPhysicalDeviceAccelerationStructureFeaturesKHR; + +typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR { + VkStructureType sType; + void* pNext; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxPrimitiveCount; + uint32_t maxPerStageDescriptorAccelerationStructures; + uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures; + uint32_t maxDescriptorSetAccelerationStructures; + uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures; + uint32_t minAccelerationStructureScratchOffsetAlignment; +} VkPhysicalDeviceAccelerationStructurePropertiesKHR; + +typedef struct VkAccelerationStructureDeviceAddressInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR accelerationStructure; +} VkAccelerationStructureDeviceAddressInfoKHR; + +typedef struct VkAccelerationStructureVersionInfoKHR { + VkStructureType sType; + const void* pNext; + const uint8_t* pVersionData; +} VkAccelerationStructureVersionInfoKHR; + +typedef struct VkCopyAccelerationStructureToMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR src; + VkDeviceOrHostAddressKHR dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyAccelerationStructureToMemoryInfoKHR; + +typedef struct VkCopyMemoryToAccelerationStructureInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR src; + VkAccelerationStructureKHR dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyMemoryToAccelerationStructureInfoKHR; + +typedef struct VkCopyAccelerationStructureInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR src; + VkAccelerationStructureKHR dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyAccelerationStructureInfoKHR; + +typedef struct VkAccelerationStructureBuildSizesInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceSize accelerationStructureSize; + VkDeviceSize updateScratchSize; + VkDeviceSize buildScratchSize; +} VkAccelerationStructureBuildSizesInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); +typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts); +typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure); + +VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR( + VkDevice device, + VkAccelerationStructureKHR accelerationStructure, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkDeviceAddress* pIndirectDeviceAddresses, + const uint32_t* pIndirectStrides, + const uint32_t* const* ppMaxPrimitiveCounts); + +VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureInfoKHR* pInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR( + VkDevice device, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureInfoKHR* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); + +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR( + VkDevice device, + const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR( + VkDevice device, + const VkAccelerationStructureVersionInfoKHR* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); + +VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, + const uint32_t* pMaxPrimitiveCounts, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +#endif + + +#define VK_KHR_ray_tracing_pipeline 1 +#define VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION 1 +#define VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME "VK_KHR_ray_tracing_pipeline" + +typedef enum VkShaderGroupShaderKHR { + VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0, + VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1, + VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2, + VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3, + VK_SHADER_GROUP_SHADER_MAX_ENUM_KHR = 0x7FFFFFFF +} VkShaderGroupShaderKHR; +typedef struct VkRayTracingShaderGroupCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkRayTracingShaderGroupTypeKHR type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; + const void* pShaderGroupCaptureReplayHandle; +} VkRayTracingShaderGroupCreateInfoKHR; + +typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxPipelineRayPayloadSize; + uint32_t maxPipelineRayHitAttributeSize; +} VkRayTracingPipelineInterfaceCreateInfoKHR; + +typedef struct VkRayTracingPipelineCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const VkRayTracingShaderGroupCreateInfoKHR* pGroups; + uint32_t maxPipelineRayRecursionDepth; + const VkPipelineLibraryCreateInfoKHR* pLibraryInfo; + const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkRayTracingPipelineCreateInfoKHR; + +typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingPipeline; + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay; + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + VkBool32 rayTracingPipelineTraceRaysIndirect; + VkBool32 rayTraversalPrimitiveCulling; +} VkPhysicalDeviceRayTracingPipelineFeaturesKHR; + +typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t shaderGroupHandleSize; + uint32_t maxRayRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint32_t shaderGroupHandleCaptureReplaySize; + uint32_t maxRayDispatchInvocationCount; + uint32_t shaderGroupHandleAlignment; + uint32_t maxRayHitAttributeSize; +} VkPhysicalDeviceRayTracingPipelinePropertiesKHR; + +typedef struct VkStridedDeviceAddressRegionKHR { + VkDeviceAddress deviceAddress; + VkDeviceSize stride; + VkDeviceSize size; +} VkStridedDeviceAddressRegionKHR; + +typedef struct VkTraceRaysIndirectCommandKHR { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkTraceRaysIndirectCommandKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress); +typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader); +typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR( + VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR( + VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + VkDeviceAddress indirectDeviceAddress); + +VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t group, + VkShaderGroupShaderKHR groupShader); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR( + VkCommandBuffer commandBuffer, + uint32_t pipelineStackSize); +#endif + + +#define VK_KHR_ray_query 1 +#define VK_KHR_RAY_QUERY_SPEC_VERSION 1 +#define VK_KHR_RAY_QUERY_EXTENSION_NAME "VK_KHR_ray_query" +typedef struct VkPhysicalDeviceRayQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayQuery; +} VkPhysicalDeviceRayQueryFeaturesKHR; + + + +#define VK_EXT_mesh_shader 1 +#define VK_EXT_MESH_SHADER_SPEC_VERSION 1 +#define VK_EXT_MESH_SHADER_EXTENSION_NAME "VK_EXT_mesh_shader" +typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 taskShader; + VkBool32 meshShader; + VkBool32 multiviewMeshShader; + VkBool32 primitiveFragmentShadingRateMeshShader; + VkBool32 meshShaderQueries; +} VkPhysicalDeviceMeshShaderFeaturesEXT; + +typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxTaskWorkGroupTotalCount; + uint32_t maxTaskWorkGroupCount[3]; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskPayloadSize; + uint32_t maxTaskSharedMemorySize; + uint32_t maxTaskPayloadAndSharedMemorySize; + uint32_t maxMeshWorkGroupTotalCount; + uint32_t maxMeshWorkGroupCount[3]; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshSharedMemorySize; + uint32_t maxMeshPayloadAndSharedMemorySize; + uint32_t maxMeshOutputMemorySize; + uint32_t maxMeshPayloadAndOutputMemorySize; + uint32_t maxMeshOutputComponents; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshOutputLayers; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; + uint32_t maxPreferredTaskWorkGroupInvocations; + uint32_t maxPreferredMeshWorkGroupInvocations; + VkBool32 prefersLocalInvocationVertexOutput; + VkBool32 prefersLocalInvocationPrimitiveOutput; + VkBool32 prefersCompactVertexOutput; + VkBool32 prefersCompactPrimitiveOutput; +} VkPhysicalDeviceMeshShaderPropertiesEXT; + +typedef struct VkDrawMeshTasksIndirectCommandEXT { + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; +} VkDrawMeshTasksIndirectCommandEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksEXT)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_directfb.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_directfb.h new file mode 100644 index 000000000..81d22fa7a --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_directfb.h @@ -0,0 +1,54 @@ +#ifndef VULKAN_DIRECTFB_H_ +#define VULKAN_DIRECTFB_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_EXT_directfb_surface 1 +#define VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION 1 +#define VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME "VK_EXT_directfb_surface" +typedef VkFlags VkDirectFBSurfaceCreateFlagsEXT; +typedef struct VkDirectFBSurfaceCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDirectFBSurfaceCreateFlagsEXT flags; + IDirectFB* dfb; + IDirectFBSurface* surface; +} VkDirectFBSurfaceCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDirectFBSurfaceEXT)(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT( + VkInstance instance, + const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + IDirectFB* dfb); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_fuchsia.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_fuchsia.h new file mode 100644 index 000000000..c11d9e65b --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_fuchsia.h @@ -0,0 +1,258 @@ +#ifndef VULKAN_FUCHSIA_H_ +#define VULKAN_FUCHSIA_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_FUCHSIA_imagepipe_surface 1 +#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1 +#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface" +typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA; +typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkImagePipeSurfaceCreateFlagsFUCHSIA flags; + zx_handle_t imagePipeHandle; +} VkImagePipeSurfaceCreateInfoFUCHSIA; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA( + VkInstance instance, + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + + +#define VK_FUCHSIA_external_memory 1 +#define VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME "VK_FUCHSIA_external_memory" +typedef struct VkImportMemoryZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + zx_handle_t handle; +} VkImportMemoryZirconHandleInfoFUCHSIA; + +typedef struct VkMemoryZirconHandlePropertiesFUCHSIA { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryZirconHandlePropertiesFUCHSIA; + +typedef struct VkMemoryGetZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetZirconHandleInfoFUCHSIA; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA( + VkDevice device, + const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + zx_handle_t zirconHandle, + VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); +#endif + + +#define VK_FUCHSIA_external_semaphore 1 +#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 +#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_FUCHSIA_external_semaphore" +typedef struct VkImportSemaphoreZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + zx_handle_t zirconHandle; +} VkImportSemaphoreZirconHandleInfoFUCHSIA; + +typedef struct VkSemaphoreGetZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetZirconHandleInfoFUCHSIA; + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle); +#endif + + +#define VK_FUCHSIA_buffer_collection 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferCollectionFUCHSIA) +#define VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION 2 +#define VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME "VK_FUCHSIA_buffer_collection" +typedef VkFlags VkImageFormatConstraintsFlagsFUCHSIA; + +typedef enum VkImageConstraintsInfoFlagBitsFUCHSIA { + VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = 0x00000001, + VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = 0x00000002, + VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = 0x00000004, + VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = 0x00000008, + VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = 0x00000010, + VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIA = 0x7FFFFFFF +} VkImageConstraintsInfoFlagBitsFUCHSIA; +typedef VkFlags VkImageConstraintsInfoFlagsFUCHSIA; +typedef struct VkBufferCollectionCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + zx_handle_t collectionToken; +} VkBufferCollectionCreateInfoFUCHSIA; + +typedef struct VkImportMemoryBufferCollectionFUCHSIA { + VkStructureType sType; + const void* pNext; + VkBufferCollectionFUCHSIA collection; + uint32_t index; +} VkImportMemoryBufferCollectionFUCHSIA; + +typedef struct VkBufferCollectionImageCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkBufferCollectionFUCHSIA collection; + uint32_t index; +} VkBufferCollectionImageCreateInfoFUCHSIA; + +typedef struct VkBufferCollectionConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + uint32_t minBufferCount; + uint32_t maxBufferCount; + uint32_t minBufferCountForCamping; + uint32_t minBufferCountForDedicatedSlack; + uint32_t minBufferCountForSharedSlack; +} VkBufferCollectionConstraintsInfoFUCHSIA; + +typedef struct VkBufferConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkBufferCreateInfo createInfo; + VkFormatFeatureFlags requiredFormatFeatures; + VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; +} VkBufferConstraintsInfoFUCHSIA; + +typedef struct VkBufferCollectionBufferCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkBufferCollectionFUCHSIA collection; + uint32_t index; +} VkBufferCollectionBufferCreateInfoFUCHSIA; + +typedef struct VkSysmemColorSpaceFUCHSIA { + VkStructureType sType; + const void* pNext; + uint32_t colorSpace; +} VkSysmemColorSpaceFUCHSIA; + +typedef struct VkBufferCollectionPropertiesFUCHSIA { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; + uint32_t bufferCount; + uint32_t createInfoIndex; + uint64_t sysmemPixelFormat; + VkFormatFeatureFlags formatFeatures; + VkSysmemColorSpaceFUCHSIA sysmemColorSpaceIndex; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; +} VkBufferCollectionPropertiesFUCHSIA; + +typedef struct VkImageFormatConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkImageCreateInfo imageCreateInfo; + VkFormatFeatureFlags requiredFormatFeatures; + VkImageFormatConstraintsFlagsFUCHSIA flags; + uint64_t sysmemPixelFormat; + uint32_t colorSpaceCount; + const VkSysmemColorSpaceFUCHSIA* pColorSpaces; +} VkImageFormatConstraintsInfoFUCHSIA; + +typedef struct VkImageConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + uint32_t formatConstraintsCount; + const VkImageFormatConstraintsInfoFUCHSIA* pFormatConstraints; + VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; + VkImageConstraintsInfoFlagsFUCHSIA flags; +} VkImageConstraintsInfoFUCHSIA; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferCollectionFUCHSIA)(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection); +typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionImageConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); +typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); +typedef void (VKAPI_PTR *PFN_vkDestroyBufferCollectionFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetBufferCollectionPropertiesFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA( + VkDevice device, + const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferCollectionFUCHSIA* pCollection); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + VkBufferCollectionPropertiesFUCHSIA* pProperties); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_ggp.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_ggp.h new file mode 100644 index 000000000..2c0d5edf1 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_ggp.h @@ -0,0 +1,58 @@ +#ifndef VULKAN_GGP_H_ +#define VULKAN_GGP_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_GGP_stream_descriptor_surface 1 +#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1 +#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME "VK_GGP_stream_descriptor_surface" +typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP; +typedef struct VkStreamDescriptorSurfaceCreateInfoGGP { + VkStructureType sType; + const void* pNext; + VkStreamDescriptorSurfaceCreateFlagsGGP flags; + GgpStreamDescriptor streamDescriptor; +} VkStreamDescriptorSurfaceCreateInfoGGP; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP( + VkInstance instance, + const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + + +#define VK_GGP_frame_token 1 +#define VK_GGP_FRAME_TOKEN_SPEC_VERSION 1 +#define VK_GGP_FRAME_TOKEN_EXTENSION_NAME "VK_GGP_frame_token" +typedef struct VkPresentFrameTokenGGP { + VkStructureType sType; + const void* pNext; + GgpFrameToken frameToken; +} VkPresentFrameTokenGGP; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_ios.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_ios.h new file mode 100644 index 000000000..8c6d9e72a --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_ios.h @@ -0,0 +1,47 @@ +#ifndef VULKAN_IOS_H_ +#define VULKAN_IOS_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_MVK_ios_surface 1 +#define VK_MVK_IOS_SURFACE_SPEC_VERSION 3 +#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" +typedef VkFlags VkIOSSurfaceCreateFlagsMVK; +typedef struct VkIOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkIOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkIOSSurfaceCreateInfoMVK; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( + VkInstance instance, + const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_macos.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_macos.h new file mode 100644 index 000000000..3310e11ab --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_macos.h @@ -0,0 +1,47 @@ +#ifndef VULKAN_MACOS_H_ +#define VULKAN_MACOS_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_MVK_macos_surface 1 +#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 3 +#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" +typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; +typedef struct VkMacOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkMacOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkMacOSSurfaceCreateInfoMVK; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( + VkInstance instance, + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_metal.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_metal.h new file mode 100644 index 000000000..7127651c1 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_metal.h @@ -0,0 +1,193 @@ +#ifndef VULKAN_METAL_H_ +#define VULKAN_METAL_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_EXT_metal_surface 1 +#ifdef __OBJC__ +@class CAMetalLayer; +#else +typedef void CAMetalLayer; +#endif + +#define VK_EXT_METAL_SURFACE_SPEC_VERSION 1 +#define VK_EXT_METAL_SURFACE_EXTENSION_NAME "VK_EXT_metal_surface" +typedef VkFlags VkMetalSurfaceCreateFlagsEXT; +typedef struct VkMetalSurfaceCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkMetalSurfaceCreateFlagsEXT flags; + const CAMetalLayer* pLayer; +} VkMetalSurfaceCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT( + VkInstance instance, + const VkMetalSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + + +#define VK_EXT_metal_objects 1 +#ifdef __OBJC__ +@protocol MTLDevice; +typedef id MTLDevice_id; +#else +typedef void* MTLDevice_id; +#endif + +#ifdef __OBJC__ +@protocol MTLCommandQueue; +typedef id MTLCommandQueue_id; +#else +typedef void* MTLCommandQueue_id; +#endif + +#ifdef __OBJC__ +@protocol MTLBuffer; +typedef id MTLBuffer_id; +#else +typedef void* MTLBuffer_id; +#endif + +#ifdef __OBJC__ +@protocol MTLTexture; +typedef id MTLTexture_id; +#else +typedef void* MTLTexture_id; +#endif + +typedef struct __IOSurface* IOSurfaceRef; +#ifdef __OBJC__ +@protocol MTLSharedEvent; +typedef id MTLSharedEvent_id; +#else +typedef void* MTLSharedEvent_id; +#endif + +#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 1 +#define VK_EXT_METAL_OBJECTS_EXTENSION_NAME "VK_EXT_metal_objects" + +typedef enum VkExportMetalObjectTypeFlagBitsEXT { + VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT = 0x00000001, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT = 0x00000002, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT = 0x00000004, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT = 0x00000008, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT = 0x00000010, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT = 0x00000020, + VK_EXPORT_METAL_OBJECT_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkExportMetalObjectTypeFlagBitsEXT; +typedef VkFlags VkExportMetalObjectTypeFlagsEXT; +typedef struct VkExportMetalObjectCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkExportMetalObjectTypeFlagBitsEXT exportObjectType; +} VkExportMetalObjectCreateInfoEXT; + +typedef struct VkExportMetalObjectsInfoEXT { + VkStructureType sType; + const void* pNext; +} VkExportMetalObjectsInfoEXT; + +typedef struct VkExportMetalDeviceInfoEXT { + VkStructureType sType; + const void* pNext; + MTLDevice_id mtlDevice; +} VkExportMetalDeviceInfoEXT; + +typedef struct VkExportMetalCommandQueueInfoEXT { + VkStructureType sType; + const void* pNext; + VkQueue queue; + MTLCommandQueue_id mtlCommandQueue; +} VkExportMetalCommandQueueInfoEXT; + +typedef struct VkExportMetalBufferInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + MTLBuffer_id mtlBuffer; +} VkExportMetalBufferInfoEXT; + +typedef struct VkImportMetalBufferInfoEXT { + VkStructureType sType; + const void* pNext; + MTLBuffer_id mtlBuffer; +} VkImportMetalBufferInfoEXT; + +typedef struct VkExportMetalTextureInfoEXT { + VkStructureType sType; + const void* pNext; + VkImage image; + VkImageView imageView; + VkBufferView bufferView; + VkImageAspectFlagBits plane; + MTLTexture_id mtlTexture; +} VkExportMetalTextureInfoEXT; + +typedef struct VkImportMetalTextureInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits plane; + MTLTexture_id mtlTexture; +} VkImportMetalTextureInfoEXT; + +typedef struct VkExportMetalIOSurfaceInfoEXT { + VkStructureType sType; + const void* pNext; + VkImage image; + IOSurfaceRef ioSurface; +} VkExportMetalIOSurfaceInfoEXT; + +typedef struct VkImportMetalIOSurfaceInfoEXT { + VkStructureType sType; + const void* pNext; + IOSurfaceRef ioSurface; +} VkImportMetalIOSurfaceInfoEXT; + +typedef struct VkExportMetalSharedEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkEvent event; + MTLSharedEvent_id mtlSharedEvent; +} VkExportMetalSharedEventInfoEXT; + +typedef struct VkImportMetalSharedEventInfoEXT { + VkStructureType sType; + const void* pNext; + MTLSharedEvent_id mtlSharedEvent; +} VkImportMetalSharedEventInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkExportMetalObjectsEXT)(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT( + VkDevice device, + VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_screen.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_screen.h new file mode 100644 index 000000000..1067c0463 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_screen.h @@ -0,0 +1,54 @@ +#ifndef VULKAN_SCREEN_H_ +#define VULKAN_SCREEN_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_QNX_screen_surface 1 +#define VK_QNX_SCREEN_SURFACE_SPEC_VERSION 1 +#define VK_QNX_SCREEN_SURFACE_EXTENSION_NAME "VK_QNX_screen_surface" +typedef VkFlags VkScreenSurfaceCreateFlagsQNX; +typedef struct VkScreenSurfaceCreateInfoQNX { + VkStructureType sType; + const void* pNext; + VkScreenSurfaceCreateFlagsQNX flags; + struct _screen_context* context; + struct _screen_window* window; +} VkScreenSurfaceCreateInfoQNX; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateScreenSurfaceQNX)(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX( + VkInstance instance, + const VkScreenSurfaceCreateInfoQNX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window* window); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_vi.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_vi.h new file mode 100644 index 000000000..672647053 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_vi.h @@ -0,0 +1,47 @@ +#ifndef VULKAN_VI_H_ +#define VULKAN_VI_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_NN_vi_surface 1 +#define VK_NN_VI_SURFACE_SPEC_VERSION 1 +#define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface" +typedef VkFlags VkViSurfaceCreateFlagsNN; +typedef struct VkViSurfaceCreateInfoNN { + VkStructureType sType; + const void* pNext; + VkViSurfaceCreateFlagsNN flags; + void* window; +} VkViSurfaceCreateInfoNN; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( + VkInstance instance, + const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_wayland.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_wayland.h new file mode 100644 index 000000000..42b280184 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_wayland.h @@ -0,0 +1,54 @@ +#ifndef VULKAN_WAYLAND_H_ +#define VULKAN_WAYLAND_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_KHR_wayland_surface 1 +#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6 +#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" +typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; +typedef struct VkWaylandSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWaylandSurfaceCreateFlagsKHR flags; + struct wl_display* display; + struct wl_surface* surface; +} VkWaylandSurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( + VkInstance instance, + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_win32.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_win32.h new file mode 100644 index 000000000..5b65a36a6 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_win32.h @@ -0,0 +1,333 @@ +#ifndef VULKAN_WIN32_H_ +#define VULKAN_WIN32_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_KHR_win32_surface 1 +#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 +#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" +typedef VkFlags VkWin32SurfaceCreateFlagsKHR; +typedef struct VkWin32SurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWin32SurfaceCreateFlagsKHR flags; + HINSTANCE hinstance; + HWND hwnd; +} VkWin32SurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( + VkInstance instance, + const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex); +#endif + + +#define VK_KHR_external_memory_win32 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" +typedef struct VkImportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportMemoryWin32HandleInfoKHR; + +typedef struct VkExportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportMemoryWin32HandleInfoKHR; + +typedef struct VkMemoryWin32HandlePropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryWin32HandlePropertiesKHR; + +typedef struct VkMemoryGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetWin32HandleInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); +#endif + + +#define VK_KHR_win32_keyed_mutex 1 +#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 +#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" +typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeouts; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoKHR; + + + +#define VK_KHR_external_semaphore_win32 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" +typedef struct VkImportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportSemaphoreWin32HandleInfoKHR; + +typedef struct VkExportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportSemaphoreWin32HandleInfoKHR; + +typedef struct VkD3D12FenceSubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues; +} VkD3D12FenceSubmitInfoKHR; + +typedef struct VkSemaphoreGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetWin32HandleInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif + + +#define VK_KHR_external_fence_win32 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" +typedef struct VkImportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportFenceWin32HandleInfoKHR; + +typedef struct VkExportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportFenceWin32HandleInfoKHR; + +typedef struct VkFenceGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetWin32HandleInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif + + +#define VK_NV_external_memory_win32 1 +#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" +typedef struct VkImportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleType; + HANDLE handle; +} VkImportMemoryWin32HandleInfoNV; + +typedef struct VkExportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; +} VkExportMemoryWin32HandleInfoNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + HANDLE* pHandle); +#endif + + +#define VK_NV_win32_keyed_mutex 1 +#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2 +#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" +typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeoutMilliseconds; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoNV; + + + +#define VK_EXT_full_screen_exclusive 1 +#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4 +#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive" + +typedef enum VkFullScreenExclusiveEXT { + VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0, + VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1, + VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2, + VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3, + VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkFullScreenExclusiveEXT; +typedef struct VkSurfaceFullScreenExclusiveInfoEXT { + VkStructureType sType; + void* pNext; + VkFullScreenExclusiveEXT fullScreenExclusive; +} VkSurfaceFullScreenExclusiveInfoEXT; + +typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT { + VkStructureType sType; + void* pNext; + VkBool32 fullScreenExclusiveSupported; +} VkSurfaceCapabilitiesFullScreenExclusiveEXT; + +typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT { + VkStructureType sType; + const void* pNext; + HMONITOR hmonitor; +} VkSurfaceFullScreenExclusiveWin32InfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain); +typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain); + +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT( + VkDevice device, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkDeviceGroupPresentModeFlagsKHR* pModes); +#endif + + +#define VK_NV_acquire_winrt_display 1 +#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1 +#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display" +typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); +typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + uint32_t deviceRelativeId, + VkDisplayKHR* pDisplay); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xcb.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xcb.h new file mode 100644 index 000000000..b49aa4e2c --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xcb.h @@ -0,0 +1,55 @@ +#ifndef VULKAN_XCB_H_ +#define VULKAN_XCB_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_KHR_xcb_surface 1 +#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" +typedef VkFlags VkXcbSurfaceCreateFlagsKHR; +typedef struct VkXcbSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXcbSurfaceCreateFlagsKHR flags; + xcb_connection_t* connection; + xcb_window_t window; +} VkXcbSurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( + VkInstance instance, + const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xlib.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xlib.h new file mode 100644 index 000000000..186cdd5ef --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xlib.h @@ -0,0 +1,55 @@ +#ifndef VULKAN_XLIB_H_ +#define VULKAN_XLIB_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_KHR_xlib_surface 1 +#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" +typedef VkFlags VkXlibSurfaceCreateFlagsKHR; +typedef struct VkXlibSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXlibSurfaceCreateFlagsKHR flags; + Display* dpy; + Window window; +} VkXlibSurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( + VkInstance instance, + const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display* dpy, + VisualID visualID); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xlib_xrandr.h b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xlib_xrandr.h new file mode 100644 index 000000000..9a3b62991 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/include/vulkan/vulkan_xlib_xrandr.h @@ -0,0 +1,45 @@ +#ifndef VULKAN_XLIB_XRANDR_H_ +#define VULKAN_XLIB_XRANDR_H_ 1 + +/* +** Copyright 2015-2023 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +#define VK_EXT_acquire_xlib_display 1 +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display" +typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); +typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + VkDisplayKHR display); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + RROutput rrOutput, + VkDisplayKHR* pDisplay); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/registry/vk.xml b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/registry/vk.xml new file mode 100644 index 000000000..3f012abc4 --- /dev/null +++ b/tools/vkbridge/third_party/Vulkan-Headers-1.3.247/registry/vk.xml @@ -0,0 +1,24198 @@ + + + +Copyright 2015-2023 The Khronos Group Inc. + +SPDX-License-Identifier: Apache-2.0 OR MIT + + + +This file, vk.xml, is the Vulkan API Registry. It is a critically important +and normative part of the Vulkan Specification, including a canonical +machine-readable definition of the API, parameter and member validation +language incorporated into the Specification and reference pages, and other +material which is registered by Khronos, such as tags used by extension and +layer authors. The authoritative public version of vk.xml is maintained in +the default branch (currently named main) of the Khronos Vulkan GitHub +project. The authoritative private version is maintained in the default +branch of the member gitlab server. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + #include "vk_platform.h" + + WSI extensions + + + + + + + + + + + + + + In the current header structure, each platform's interfaces + are confined to a platform-specific header (vulkan_xlib.h, + vulkan_win32.h, etc.). These headers are not self-contained, + and should not include native headers (X11/Xlib.h, + windows.h, etc.). Code should either include vulkan.h after + defining the appropriate VK_USE_PLATFORM_platform + macros, or include the required native headers prior to + explicitly including the corresponding platform header. + + To accomplish this, the dependencies of native types require + native headers, but the XML defines the content for those + native headers as empty. The actual native header includes + can be restored by modifying the native header tags above + to #include the header file in the 'name' attribute. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead. +#define VK_MAKE_VERSION(major, minor, patch) \ + ((((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch))) + // DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead. +#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22U) + // DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead. +#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) + // DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead. +#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) + + #define VK_MAKE_API_VERSION(variant, major, minor, patch) \ + ((((uint32_t)(variant)) << 29U) | (((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch))) + #define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29U) + #define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22U) & 0x7FU) + #define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) + #define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) + + // Vulkan SC variant number +#define VKSC_API_VARIANT 1 + + // DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. +//#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 + // Vulkan 1.0 version number +#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 + // Vulkan 1.1 version number +#define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0 + // Vulkan 1.2 version number +#define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0 + // Vulkan 1.3 version number +#define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0)// Patch version should always be set to 0 + // Vulkan SC 1.0 version number +#define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0 + + // Version of this file +#define VK_HEADER_VERSION 247 + // Complete version of this file +#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) + // Version of this file +#define VK_HEADER_VERSION 12 + // Complete version of this file +#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, VK_HEADER_VERSION) + + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* (object); + + +#ifndef VK_USE_64_BIT_PTR_DEFINES + #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_USE_64_BIT_PTR_DEFINES 1 + #else + #define VK_USE_64_BIT_PTR_DEFINES 0 + #endif +#endif + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L)) + #define VK_NULL_HANDLE nullptr + #else + #define VK_NULL_HANDLE ((void*)0) + #endif + #else + #define VK_NULL_HANDLE 0ULL + #endif +#endif +#ifndef VK_NULL_HANDLE + #define VK_NULL_HANDLE 0 +#endif + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; + #else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; + #endif +#endif + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *(object); + #else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t (object); + #endif +#endif + + struct ANativeWindow; + struct AHardwareBuffer; + #ifdef __OBJC__ +@class CAMetalLayer; +#else +typedef void CAMetalLayer; +#endif + #ifdef __OBJC__ +@protocol MTLDevice; +typedef id<MTLDevice> MTLDevice_id; +#else +typedef void* MTLDevice_id; +#endif + #ifdef __OBJC__ +@protocol MTLCommandQueue; +typedef id<MTLCommandQueue> MTLCommandQueue_id; +#else +typedef void* MTLCommandQueue_id; +#endif + #ifdef __OBJC__ +@protocol MTLBuffer; +typedef id<MTLBuffer> MTLBuffer_id; +#else +typedef void* MTLBuffer_id; +#endif + #ifdef __OBJC__ +@protocol MTLTexture; +typedef id<MTLTexture> MTLTexture_id; +#else +typedef void* MTLTexture_id; +#endif + #ifdef __OBJC__ +@protocol MTLSharedEvent; +typedef id<MTLSharedEvent> MTLSharedEvent_id; +#else +typedef void* MTLSharedEvent_id; +#endif + typedef struct __IOSurface* IOSurfaceRef; + + typedef uint32_t VkSampleMask; + typedef uint32_t VkBool32; + typedef uint32_t VkFlags; + typedef uint64_t VkFlags64; + typedef uint64_t VkDeviceSize; + typedef uint64_t VkDeviceAddress; + + Basic C types, pulled in via vk_platform.h + + + + + + + + + + + + + + + + Bitmask types + typedef VkFlags VkFramebufferCreateFlags; + typedef VkFlags VkQueryPoolCreateFlags; + typedef VkFlags VkRenderPassCreateFlags; + typedef VkFlags VkSamplerCreateFlags; + typedef VkFlags VkPipelineLayoutCreateFlags; + typedef VkFlags VkPipelineCacheCreateFlags; + typedef VkFlags VkPipelineDepthStencilStateCreateFlags; + typedef VkFlags VkPipelineDepthStencilStateCreateFlags; + typedef VkFlags VkPipelineDynamicStateCreateFlags; + typedef VkFlags VkPipelineColorBlendStateCreateFlags; + typedef VkFlags VkPipelineColorBlendStateCreateFlags; + typedef VkFlags VkPipelineMultisampleStateCreateFlags; + typedef VkFlags VkPipelineRasterizationStateCreateFlags; + typedef VkFlags VkPipelineViewportStateCreateFlags; + typedef VkFlags VkPipelineTessellationStateCreateFlags; + typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; + typedef VkFlags VkPipelineVertexInputStateCreateFlags; + typedef VkFlags VkPipelineShaderStageCreateFlags; + typedef VkFlags VkDescriptorSetLayoutCreateFlags; + typedef VkFlags VkBufferViewCreateFlags; + typedef VkFlags VkInstanceCreateFlags; + typedef VkFlags VkDeviceCreateFlags; + typedef VkFlags VkDeviceQueueCreateFlags; + typedef VkFlags VkQueueFlags; + typedef VkFlags VkMemoryPropertyFlags; + typedef VkFlags VkMemoryHeapFlags; + typedef VkFlags VkAccessFlags; + typedef VkFlags VkBufferUsageFlags; + typedef VkFlags VkBufferCreateFlags; + typedef VkFlags VkShaderStageFlags; + typedef VkFlags VkImageUsageFlags; + typedef VkFlags VkImageCreateFlags; + typedef VkFlags VkImageViewCreateFlags; + typedef VkFlags VkPipelineCreateFlags; + typedef VkFlags VkColorComponentFlags; + typedef VkFlags VkFenceCreateFlags; + typedef VkFlags VkSemaphoreCreateFlags; + typedef VkFlags VkFormatFeatureFlags; + typedef VkFlags VkQueryControlFlags; + typedef VkFlags VkQueryResultFlags; + typedef VkFlags VkShaderModuleCreateFlags; + typedef VkFlags VkEventCreateFlags; + typedef VkFlags VkCommandPoolCreateFlags; + typedef VkFlags VkCommandPoolResetFlags; + typedef VkFlags VkCommandBufferResetFlags; + typedef VkFlags VkCommandBufferUsageFlags; + typedef VkFlags VkQueryPipelineStatisticFlags; + typedef VkFlags VkMemoryMapFlags; + typedef VkFlags VkImageAspectFlags; + typedef VkFlags VkSparseMemoryBindFlags; + typedef VkFlags VkSparseImageFormatFlags; + typedef VkFlags VkSubpassDescriptionFlags; + typedef VkFlags VkPipelineStageFlags; + typedef VkFlags VkSampleCountFlags; + typedef VkFlags VkAttachmentDescriptionFlags; + typedef VkFlags VkStencilFaceFlags; + typedef VkFlags VkCullModeFlags; + typedef VkFlags VkDescriptorPoolCreateFlags; + typedef VkFlags VkDescriptorPoolResetFlags; + typedef VkFlags VkDependencyFlags; + typedef VkFlags VkSubgroupFeatureFlags; + typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV; + typedef VkFlags VkIndirectStateFlagsNV; + typedef VkFlags VkGeometryFlagsKHR; + + typedef VkFlags VkGeometryInstanceFlagsKHR; + + typedef VkFlags VkBuildAccelerationStructureFlagsKHR; + + typedef VkFlags VkPrivateDataSlotCreateFlags; + + typedef VkFlags VkAccelerationStructureCreateFlagsKHR; + typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; + + typedef VkFlags VkPipelineCreationFeedbackFlags; + + typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; + typedef VkFlags VkAcquireProfilingLockFlagsKHR; + typedef VkFlags VkSemaphoreWaitFlags; + + typedef VkFlags VkPipelineCompilerControlFlagsAMD; + typedef VkFlags VkShaderCorePropertiesFlagsAMD; + typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV; + typedef VkFlags VkRefreshObjectFlagsKHR; + typedef VkFlags64 VkAccessFlags2; + + typedef VkFlags64 VkPipelineStageFlags2; + + typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV; + typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV; + typedef VkFlags64 VkFormatFeatureFlags2; + + typedef VkFlags VkRenderingFlags; + typedef VkFlags64 VkMemoryDecompressionMethodFlagsNV; + + typedef VkFlags VkBuildMicromapFlagsEXT; + typedef VkFlags VkMicromapCreateFlagsEXT; + typedef VkFlags VkDirectDriverLoadingFlagsLUNARG; + + WSI extensions + typedef VkFlags VkCompositeAlphaFlagsKHR; + typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; + typedef VkFlags VkSurfaceTransformFlagsKHR; + typedef VkFlags VkSwapchainCreateFlagsKHR; + typedef VkFlags VkDisplayModeCreateFlagsKHR; + typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; + typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; + typedef VkFlags VkViSurfaceCreateFlagsNN; + typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; + typedef VkFlags VkWin32SurfaceCreateFlagsKHR; + typedef VkFlags VkXlibSurfaceCreateFlagsKHR; + typedef VkFlags VkXcbSurfaceCreateFlagsKHR; + typedef VkFlags VkDirectFBSurfaceCreateFlagsEXT; + typedef VkFlags VkIOSSurfaceCreateFlagsMVK; + typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; + typedef VkFlags VkMetalSurfaceCreateFlagsEXT; + typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA; + typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP; + typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; + typedef VkFlags VkScreenSurfaceCreateFlagsQNX; + typedef VkFlags VkPeerMemoryFeatureFlags; + + typedef VkFlags VkMemoryAllocateFlags; + + typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; + + typedef VkFlags VkDebugReportFlagsEXT; + typedef VkFlags VkCommandPoolTrimFlags; + + typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; + typedef VkFlags VkExternalMemoryFeatureFlagsNV; + typedef VkFlags VkExternalMemoryHandleTypeFlags; + + typedef VkFlags VkExternalMemoryFeatureFlags; + + typedef VkFlags VkExternalSemaphoreHandleTypeFlags; + + typedef VkFlags VkExternalSemaphoreFeatureFlags; + + typedef VkFlags VkSemaphoreImportFlags; + + typedef VkFlags VkExternalFenceHandleTypeFlags; + + typedef VkFlags VkExternalFenceFeatureFlags; + + typedef VkFlags VkFenceImportFlags; + + typedef VkFlags VkSurfaceCounterFlagsEXT; + typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; + typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; + typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; + typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; + typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV; + typedef VkFlags VkValidationCacheCreateFlagsEXT; + typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; + typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; + typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; + typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; + typedef VkFlags VkDeviceMemoryReportFlagsEXT; + typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; + typedef VkFlags VkDescriptorBindingFlags; + + typedef VkFlags VkConditionalRenderingFlagsEXT; + typedef VkFlags VkResolveModeFlags; + + typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT; + typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; + typedef VkFlags VkSwapchainImageUsageFlagsANDROID; + typedef VkFlags VkToolPurposeFlags; + + typedef VkFlags VkSubmitFlags; + + typedef VkFlags VkImageFormatConstraintsFlagsFUCHSIA; + typedef VkFlags VkImageConstraintsInfoFlagsFUCHSIA; + typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT; + typedef VkFlags VkImageCompressionFlagsEXT; + typedef VkFlags VkImageCompressionFixedRateFlagsEXT; + typedef VkFlags VkExportMetalObjectTypeFlagsEXT; + typedef VkFlags VkDeviceAddressBindingFlagsEXT; + typedef VkFlags VkOpticalFlowGridSizeFlagsNV; + typedef VkFlags VkOpticalFlowUsageFlagsNV; + typedef VkFlags VkOpticalFlowSessionCreateFlagsNV; + typedef VkFlags VkOpticalFlowExecuteFlagsNV; + typedef VkFlags VkPresentScalingFlagsEXT; + typedef VkFlags VkPresentGravityFlagsEXT; + typedef VkFlags VkShaderCreateFlagsEXT; + + Video Core extension + typedef VkFlags VkVideoCodecOperationFlagsKHR; + typedef VkFlags VkVideoCapabilityFlagsKHR; + typedef VkFlags VkVideoSessionCreateFlagsKHR; + typedef VkFlags VkVideoSessionParametersCreateFlagsKHR; + typedef VkFlags VkVideoBeginCodingFlagsKHR; + typedef VkFlags VkVideoEndCodingFlagsKHR; + typedef VkFlags VkVideoCodingControlFlagsKHR; + + Video Decode Core extension + typedef VkFlags VkVideoDecodeUsageFlagsKHR; + typedef VkFlags VkVideoDecodeCapabilityFlagsKHR; + typedef VkFlags VkVideoDecodeFlagsKHR; + + Video Decode H.264 extension + typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsKHR; + + Video Encode Core extension + typedef VkFlags VkVideoEncodeFlagsKHR; + typedef VkFlags VkVideoEncodeUsageFlagsKHR; + typedef VkFlags VkVideoEncodeContentFlagsKHR; + typedef VkFlags VkVideoEncodeCapabilityFlagsKHR; + typedef VkFlags VkVideoEncodeFeedbackFlagsKHR; + typedef VkFlags VkVideoEncodeRateControlFlagsKHR; + typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; + typedef VkFlags VkVideoChromaSubsamplingFlagsKHR; + typedef VkFlags VkVideoComponentBitDepthFlagsKHR; + + Video Encode H.264 extension + typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT; + + Video Encode H.265 extension + typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT; + typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT; + typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT; + typedef VkFlags VkMemoryUnmapFlagsKHR; + + Types which can be void pointers or class pointers, selected at compile time + VK_DEFINE_HANDLE(VkInstance) + VK_DEFINE_HANDLE(VkPhysicalDevice) + VK_DEFINE_HANDLE(VkDevice) + VK_DEFINE_HANDLE(VkQueue) + VK_DEFINE_HANDLE(VkCommandBuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) + + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) + + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferCollectionFUCHSIA) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlot) + + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkOpticalFlowSessionNV) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkMicromapEXT) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderEXT) + + WSI extensions + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) + + Video extensions + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR) + + VK_NV_external_sci_sync2 + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphoreSciSyncPoolNV) + + Types generated from corresponding enums tags below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Extensions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + WSI extensions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Enumerated types in the header, but not used by the API + + + + + + + + Video Core extensions + + + + + + + + + Video Decode extensions + + + + Video H.264 Decode extensions + + + Video H.265 Decode extensions + + Video Encode extensions + + + + + + + + Video H.264 Encode extensions + + + + Video H.265 Encode extensions + + + + + + The PFN_vk*Function types are used by VkAllocationCallbacks below + typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + + The PFN_vkVoidFunction type are used by VkGet*ProcAddr below + typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); + + The PFN_vkDebugReportCallbackEXT type are used by the DEBUG_REPORT extension + typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + + The PFN_vkDebugUtilsMessengerCallbackEXT type are used by the VK_EXT_debug_utils extension + typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + + The PFN_vkFaultCallbackFunction type is used by VKSC_VERSION_1_0 + typedef void (VKAPI_PTR *PFN_vkFaultCallbackFunction)( + VkBool32 unrecordedFaults, + uint32_t faultCount, + const VkFaultData* pFaults); + + The PFN_vkDeviceMemoryReportCallbackEXT type is used by the VK_EXT_device_memory_report extension + typedef void (VKAPI_PTR *PFN_vkDeviceMemoryReportCallbackEXT)( + const VkDeviceMemoryReportCallbackDataEXT* pCallbackData, + void* pUserData); + + The PFN_vkGetInstanceProcAddrLUNARG type is used by the + VkDirectDriverLoadingInfoLUNARG structure. + We cannot introduce an explicit dependency on the + equivalent PFN_vkGetInstanceProcAddr type, even though + it is implicitly generated in the C header, because + that results in multiple definitions. + typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddrLUNARG)( + VkInstance instance, const char* pName); + + Struct types + + VkStructureType sType + struct VkBaseOutStructure* pNext + + + VkStructureType sType + const struct VkBaseInStructure* pNext + + + int32_t x + int32_t y + + + int32_t x + int32_t y + int32_t z + + + uint32_t width + uint32_t height + + + uint32_t width + uint32_t height + uint32_t depth + + + float x + float y + float width + float height + float minDepth + float maxDepth + + + VkOffset2D offset + VkExtent2D extent + + + VkRect2D rect + uint32_t baseArrayLayer + uint32_t layerCount + + + VkComponentSwizzle r + VkComponentSwizzle g + VkComponentSwizzle b + VkComponentSwizzle a + + + uint32_t apiVersion + uint32_t driverVersion + uint32_t vendorID + uint32_t deviceID + VkPhysicalDeviceType deviceType + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] + uint8_t pipelineCacheUUID[VK_UUID_SIZE] + VkPhysicalDeviceLimits limits + VkPhysicalDeviceSparseProperties sparseProperties + + + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]extension name + uint32_t specVersionversion of the extension specification implemented + + + char layerName[VK_MAX_EXTENSION_NAME_SIZE]layer name + uint32_t specVersionversion of the layer specification implemented + uint32_t implementationVersionbuild or release version of the layer's library + char description[VK_MAX_DESCRIPTION_SIZE]Free-form description of the layer + + + VkStructureType sType + const void* pNext + const char* pApplicationName + uint32_t applicationVersion + const char* pEngineName + uint32_t engineVersion + uint32_t apiVersion + + + void* pUserData + PFN_vkAllocationFunction pfnAllocation + PFN_vkReallocationFunction pfnReallocation + PFN_vkFreeFunction pfnFree + PFN_vkInternalAllocationNotification pfnInternalAllocation + PFN_vkInternalFreeNotification pfnInternalFree + + + VkStructureType sType + const void* pNext + VkDeviceQueueCreateFlags flags + uint32_t queueFamilyIndex + uint32_t queueCount + const float* pQueuePriorities + + + VkStructureType sType + const void* pNext + VkDeviceCreateFlags flags + uint32_t queueCreateInfoCount + const VkDeviceQueueCreateInfo* pQueueCreateInfos + uint32_t enabledLayerCount + const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled + uint32_t enabledExtensionCount + const char* const* ppEnabledExtensionNames + const VkPhysicalDeviceFeatures* pEnabledFeatures + + + VkStructureType sType + const void* pNext + VkInstanceCreateFlags flags + const VkApplicationInfo* pApplicationInfo + uint32_t enabledLayerCount + const char* const* ppEnabledLayerNamesOrdered list of layer names to be enabled + uint32_t enabledExtensionCount + const char* const* ppEnabledExtensionNamesExtension names to be enabled + + + VkQueueFlags queueFlagsQueue flags + uint32_t queueCount + uint32_t timestampValidBits + VkExtent3D minImageTransferGranularityMinimum alignment requirement for image transfers + + + uint32_t memoryTypeCount + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES] + uint32_t memoryHeapCount + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS] + + + VkStructureType sType + const void* pNext + VkDeviceSize allocationSizeSize of memory allocation + uint32_t memoryTypeIndexIndex of the of the memory type to allocate from + + + VkDeviceSize sizeSpecified in bytes + VkDeviceSize alignmentSpecified in bytes + uint32_t memoryTypeBitsBitmask of the allowed memory type indices into memoryTypes[] for this object + + + VkImageAspectFlags aspectMask + VkExtent3D imageGranularity + VkSparseImageFormatFlags flags + + + VkSparseImageFormatProperties formatProperties + uint32_t imageMipTailFirstLod + VkDeviceSize imageMipTailSizeSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + VkDeviceSize imageMipTailOffsetSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + VkDeviceSize imageMipTailStrideSpecified in bytes, must be a multiple of sparse block size in bytes / alignment + + + VkMemoryPropertyFlags propertyFlagsMemory properties of this memory type + uint32_t heapIndexIndex of the memory heap allocations of this memory type are taken from + + + VkDeviceSize sizeAvailable memory in the heap + VkMemoryHeapFlags flagsFlags for the heap + + + VkStructureType sType + const void* pNext + VkDeviceMemory memoryMapped memory object + VkDeviceSize offsetOffset within the memory object where the range starts + VkDeviceSize sizeSize of the range within the memory object + + + VkFormatFeatureFlags linearTilingFeaturesFormat features in case of linear tiling + VkFormatFeatureFlags optimalTilingFeaturesFormat features in case of optimal tiling + VkFormatFeatureFlags bufferFeaturesFormat features supported by buffers + + + VkExtent3D maxExtentmax image dimensions for this resource type + uint32_t maxMipLevelsmax number of mipmap levels for this resource type + uint32_t maxArrayLayersmax array size for this resource type + VkSampleCountFlags sampleCountssupported sample counts for this resource type + VkDeviceSize maxResourceSizemax size (in bytes) of this resource type + + + VkBuffer bufferBuffer used for this descriptor slot. + VkDeviceSize offsetBase offset from buffer start in bytes to update in the descriptor set. + VkDeviceSize rangeSize in bytes of the buffer resource for this descriptor update. + + + VkSampler samplerSampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise. + VkImageView imageViewImage view to write to the descriptor in case it is a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor. Ignored otherwise. + VkImageLayout imageLayoutLayout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE). + + + VkStructureType sType + const void* pNext + VkDescriptorSet dstSetDestination descriptor set + uint32_t dstBindingBinding within the destination descriptor set to write + uint32_t dstArrayElementArray element within the destination binding to write + uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) + VkDescriptorType descriptorTypeDescriptor type to write (determines which members of the array pointed by pDescriptors are going to be used) + const VkDescriptorImageInfo* pImageInfoSampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types. + const VkDescriptorBufferInfo* pBufferInfoRaw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types. + const VkBufferView* pTexelBufferViewBuffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types. + + + VkStructureType sType + const void* pNext + VkDescriptorSet srcSetSource descriptor set + uint32_t srcBindingBinding within the source descriptor set to copy from + uint32_t srcArrayElementArray element within the source binding to copy from + VkDescriptorSet dstSetDestination descriptor set + uint32_t dstBindingBinding within the destination descriptor set to copy to + uint32_t dstArrayElementArray element within the destination binding to copy to + uint32_t descriptorCountNumber of descriptors to write (determines the size of the array pointed by pDescriptors) + + + VkStructureType sType + const void* pNext + VkBufferCreateFlags flagsBuffer creation flags + VkDeviceSize sizeSpecified in bytes + VkBufferUsageFlags usageBuffer usage flags + VkSharingMode sharingMode + uint32_t queueFamilyIndexCount + const uint32_t* pQueueFamilyIndices + + + VkStructureType sType + const void* pNext + VkBufferViewCreateFlags flags + VkBuffer buffer + VkFormat formatOptionally specifies format of elements + VkDeviceSize offsetSpecified in bytes + VkDeviceSize rangeView size specified in bytes + + + VkImageAspectFlags aspectMask + uint32_t mipLevel + uint32_t arrayLayer + + + VkImageAspectFlags aspectMask + uint32_t mipLevel + uint32_t baseArrayLayer + uint32_t layerCount + + + VkImageAspectFlags aspectMask + uint32_t baseMipLevel + uint32_t levelCount + uint32_t baseArrayLayer + uint32_t layerCount + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + uint32_t srcQueueFamilyIndexQueue family to transition ownership from + uint32_t dstQueueFamilyIndexQueue family to transition ownership to + VkBuffer bufferBuffer to sync + VkDeviceSize offsetOffset within the buffer to sync + VkDeviceSize sizeAmount of bytes to sync + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + VkImageLayout oldLayoutCurrent layout of the image + VkImageLayout newLayoutNew layout to transition the image to + uint32_t srcQueueFamilyIndexQueue family to transition ownership from + uint32_t dstQueueFamilyIndexQueue family to transition ownership to + VkImage imageImage to sync + VkImageSubresourceRange subresourceRangeSubresource range to sync + + + VkStructureType sType + const void* pNext + VkImageCreateFlags flagsImage creation flags + VkImageType imageType + VkFormat format + VkExtent3D extent + uint32_t mipLevels + uint32_t arrayLayers + VkSampleCountFlagBits samples + VkImageTiling tiling + VkImageUsageFlags usageImage usage flags + VkSharingMode sharingModeCross-queue-family sharing mode + uint32_t queueFamilyIndexCountNumber of queue families to share across + const uint32_t* pQueueFamilyIndicesArray of queue family indices to share across + VkImageLayout initialLayoutInitial image layout for all subresources + + + VkDeviceSize offsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + VkDeviceSize rowPitchSpecified in bytes + VkDeviceSize arrayPitchSpecified in bytes + VkDeviceSize depthPitchSpecified in bytes + + + VkStructureType sType + const void* pNext + VkImageViewCreateFlags flags + VkImage image + VkImageViewType viewType + VkFormat format + VkComponentMapping components + VkImageSubresourceRange subresourceRange + + + VkDeviceSize srcOffsetSpecified in bytes + VkDeviceSize dstOffsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + + + VkDeviceSize resourceOffsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + VkDeviceMemory memory + VkDeviceSize memoryOffsetSpecified in bytes + VkSparseMemoryBindFlags flags + + + VkImageSubresource subresource + VkOffset3D offset + VkExtent3D extent + VkDeviceMemory memory + VkDeviceSize memoryOffsetSpecified in bytes + VkSparseMemoryBindFlags flags + + + VkBuffer buffer + uint32_t bindCount + const VkSparseMemoryBind* pBinds + + + VkImage image + uint32_t bindCount + const VkSparseMemoryBind* pBinds + + + VkImage image + uint32_t bindCount + const VkSparseImageMemoryBind* pBinds + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + uint32_t bufferBindCount + const VkSparseBufferMemoryBindInfo* pBufferBinds + uint32_t imageOpaqueBindCount + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds + uint32_t imageBindCount + const VkSparseImageMemoryBindInfo* pImageBinds + uint32_t signalSemaphoreCount + const VkSemaphore* pSignalSemaphores + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsetSpecified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D extentSpecified in pixels for both compressed and uncompressed images + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsets[2]Specified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsets[2]Specified in pixels for both compressed and uncompressed images + + + VkDeviceSize bufferOffsetSpecified in bytes + uint32_t bufferRowLengthSpecified in texels + uint32_t bufferImageHeight + VkImageSubresourceLayers imageSubresource + VkOffset3D imageOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D imageExtentSpecified in pixels for both compressed and uncompressed images + + + VkDeviceAddress srcAddress + VkDeviceAddress dstAddress + VkDeviceSize sizeSpecified in bytes + + + VkDeviceAddress srcAddress + uint32_t bufferRowLengthSpecified in texels + uint32_t bufferImageHeight + VkImageSubresourceLayers imageSubresource + VkOffset3D imageOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D imageExtentSpecified in pixels for both compressed and uncompressed images + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffset + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffset + VkExtent3D extent + + + VkStructureType sType + const void* pNextnoautovalidity because this structure can be either an explicit parameter, or passed in a pNext chain + VkShaderModuleCreateFlags flags + size_t codeSizeSpecified in bytes + const uint32_t* pCodeBinary code of size codeSize + + + uint32_t bindingBinding number for this entry + VkDescriptorType descriptorTypeType of the descriptors in this binding + uint32_t descriptorCountNumber of descriptors in this binding + VkShaderStageFlags stageFlagsShader stages this binding is visible to + const VkSampler* pImmutableSamplersImmutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements) + + + VkStructureType sType + const void* pNext + VkDescriptorSetLayoutCreateFlags flags + uint32_t bindingCountNumber of bindings in the descriptor set layout + const VkDescriptorSetLayoutBinding* pBindingsArray of descriptor set layout bindings + + + VkDescriptorType type + uint32_t descriptorCount + + + VkStructureType sType + const void* pNext + VkDescriptorPoolCreateFlags flags + uint32_t maxSets + uint32_t poolSizeCount + const VkDescriptorPoolSize* pPoolSizes + + + VkStructureType sType + const void* pNext + VkDescriptorPool descriptorPool + uint32_t descriptorSetCount + const VkDescriptorSetLayout* pSetLayouts + + + uint32_t constantIDThe SpecConstant ID specified in the BIL + uint32_t offsetOffset of the value in the data block + size_t sizeSize in bytes of the SpecConstant + + + uint32_t mapEntryCountNumber of entries in the map + const VkSpecializationMapEntry* pMapEntriesArray of map entries + size_t dataSizeSize in bytes of pData + const void* pDataPointer to SpecConstant data + + + VkStructureType sType + const void* pNext + VkPipelineShaderStageCreateFlags flags + VkShaderStageFlagBits stageShader stage + VkShaderModule moduleModule containing entry point + const char* pNameNull-terminated entry point name + const char* pNameNull-terminated entry point name + const VkSpecializationInfo* pSpecializationInfo + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + VkPipelineShaderStageCreateInfo stage + VkPipelineLayout layoutInterface layout of the pipeline + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + uint32_t bindingVertex buffer binding id + uint32_t strideDistance between vertices in bytes (0 = no advancement) + VkVertexInputRate inputRateThe rate at which the vertex data is consumed + + + uint32_t locationlocation of the shader vertex attrib + uint32_t bindingVertex buffer binding id + VkFormat formatformat of source data + uint32_t offsetOffset of first element in bytes from base of vertex + + + VkStructureType sType + const void* pNext + VkPipelineVertexInputStateCreateFlags flags + uint32_t vertexBindingDescriptionCountnumber of bindings + const VkVertexInputBindingDescription* pVertexBindingDescriptions + uint32_t vertexAttributeDescriptionCountnumber of attributes + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions + + + VkStructureType sType + const void* pNext + VkPipelineInputAssemblyStateCreateFlags flags + VkPrimitiveTopology topology + VkBool32 primitiveRestartEnable + + + VkStructureType sType + const void* pNext + VkPipelineTessellationStateCreateFlags flags + uint32_t patchControlPoints + + + VkStructureType sType + const void* pNext + VkPipelineViewportStateCreateFlags flags + uint32_t viewportCount + const VkViewport* pViewports + uint32_t scissorCount + const VkRect2D* pScissors + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationStateCreateFlags flags + VkBool32 depthClampEnable + VkBool32 rasterizerDiscardEnable + VkPolygonMode polygonModeoptional (GL45) + VkCullModeFlags cullMode + VkFrontFace frontFace + VkBool32 depthBiasEnable + float depthBiasConstantFactor + float depthBiasClamp + float depthBiasSlopeFactor + float lineWidth + + + VkStructureType sType + const void* pNext + VkPipelineMultisampleStateCreateFlags flags + VkSampleCountFlagBits rasterizationSamplesNumber of samples used for rasterization + VkBool32 sampleShadingEnableoptional (GL45) + float minSampleShadingoptional (GL45) + const VkSampleMask* pSampleMaskArray of sampleMask words + VkBool32 alphaToCoverageEnable + VkBool32 alphaToOneEnable + + + VkBool32 blendEnable + VkBlendFactor srcColorBlendFactor + VkBlendFactor dstColorBlendFactor + VkBlendOp colorBlendOp + VkBlendFactor srcAlphaBlendFactor + VkBlendFactor dstAlphaBlendFactor + VkBlendOp alphaBlendOp + VkColorComponentFlags colorWriteMask + + + VkStructureType sType + const void* pNext + VkPipelineColorBlendStateCreateFlags flags + VkBool32 logicOpEnable + VkLogicOp logicOp + uint32_t attachmentCount# of pAttachments + const VkPipelineColorBlendAttachmentState* pAttachments + float blendConstants[4] + + + VkStructureType sType + const void* pNext + VkPipelineDynamicStateCreateFlags flags + uint32_t dynamicStateCount + const VkDynamicState* pDynamicStates + + + VkStencilOp failOp + VkStencilOp passOp + VkStencilOp depthFailOp + VkCompareOp compareOp + uint32_t compareMask + uint32_t writeMask + uint32_t reference + + + VkStructureType sType + const void* pNext + VkPipelineDepthStencilStateCreateFlags flags + VkBool32 depthTestEnable + VkBool32 depthWriteEnable + VkCompareOp depthCompareOp + VkBool32 depthBoundsTestEnableoptional (depth_bounds_test) + VkBool32 stencilTestEnable + VkStencilOpState front + VkStencilOpState back + float minDepthBounds + float maxDepthBounds + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + uint32_t stageCount + const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage + const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage + const VkPipelineVertexInputStateCreateInfo* pVertexInputState + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState + const VkPipelineTessellationStateCreateInfo* pTessellationState + const VkPipelineViewportStateCreateInfo* pViewportState + const VkPipelineRasterizationStateCreateInfo* pRasterizationState + const VkPipelineMultisampleStateCreateInfo* pMultisampleState + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState + const VkPipelineColorBlendStateCreateInfo* pColorBlendState + const VkPipelineDynamicStateCreateInfo* pDynamicState + VkPipelineLayout layoutInterface layout of the pipeline + VkRenderPass renderPass + uint32_t subpass + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + VkStructureType sType + const void* pNext + VkPipelineCacheCreateFlags flags + size_t initialDataSizeSize of initial data to populate cache, in bytes + size_t initialDataSizeSize of initial data to populate cache, in bytes + const void* pInitialDataInitial data to populate cache + + + The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout. + uint32_t headerSize + VkPipelineCacheHeaderVersion headerVersion + uint32_t vendorID + uint32_t deviceID + uint8_t pipelineCacheUUID[VK_UUID_SIZE] + + + The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout. + uint64_t codeSize + uint64_t codeOffset + + + The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout. + uint8_t pipelineIdentifier[VK_UUID_SIZE] + uint64_t pipelineMemorySize + uint64_t jsonSize + uint64_t jsonOffset + uint32_t stageIndexCount + uint32_t stageIndexStride + uint64_t stageIndexOffset + + + The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout. + VkPipelineCacheHeaderVersionOne headerVersionOne + VkPipelineCacheValidationVersion validationVersion + uint32_t implementationData + uint32_t pipelineIndexCount + uint32_t pipelineIndexStride + uint64_t pipelineIndexOffset + + + VkShaderStageFlags stageFlagsWhich stages use the range + uint32_t offsetStart of the range, in bytes + uint32_t sizeSize of the range, in bytes + + + VkStructureType sType + const void* pNext + VkPipelineLayoutCreateFlags flags + uint32_t setLayoutCountNumber of descriptor sets interfaced by the pipeline + const VkDescriptorSetLayout* pSetLayoutsArray of setCount number of descriptor set layout objects defining the layout of the + uint32_t pushConstantRangeCountNumber of push-constant ranges used by the pipeline + const VkPushConstantRange* pPushConstantRangesArray of pushConstantRangeCount number of ranges used by various shader stages + + + VkStructureType sType + const void* pNext + VkSamplerCreateFlags flags + VkFilter magFilterFilter mode for magnification + VkFilter minFilterFilter mode for minifiation + VkSamplerMipmapMode mipmapModeMipmap selection mode + VkSamplerAddressMode addressModeU + VkSamplerAddressMode addressModeV + VkSamplerAddressMode addressModeW + float mipLodBias + VkBool32 anisotropyEnable + float maxAnisotropy + VkBool32 compareEnable + VkCompareOp compareOp + float minLod + float maxLod + VkBorderColor borderColor + VkBool32 unnormalizedCoordinates + + + VkStructureType sType + const void* pNext + VkCommandPoolCreateFlags flagsCommand pool creation flags + uint32_t queueFamilyIndex + + + VkStructureType sType + const void* pNext + VkCommandPool commandPool + VkCommandBufferLevel level + uint32_t commandBufferCount + + + VkStructureType sType + const void* pNext + VkRenderPass renderPassRender pass for secondary command buffers + uint32_t subpass + VkFramebuffer framebufferFramebuffer for secondary command buffers + VkBool32 occlusionQueryEnableWhether this secondary command buffer may be executed during an occlusion query + VkQueryControlFlags queryFlagsQuery flags used by this secondary command buffer, if executed during an occlusion query + VkQueryPipelineStatisticFlags pipelineStatisticsPipeline statistics that may be counted for this secondary command buffer + + + VkStructureType sType + const void* pNext + VkCommandBufferUsageFlags flagsCommand buffer usage flags + const VkCommandBufferInheritanceInfo* pInheritanceInfoPointer to inheritance info for secondary command buffers + + + VkStructureType sType + const void* pNext + VkRenderPass renderPass + VkFramebuffer framebuffer + VkRect2D renderArea + uint32_t clearValueCount + const VkClearValue* pClearValues + + + float float32[4] + int32_t int32[4] + uint32_t uint32[4] + + + float depth + uint32_t stencil + + + VkClearColorValue color + VkClearDepthStencilValue depthStencil + + + VkImageAspectFlags aspectMask + uint32_t colorAttachment + VkClearValue clearValue + + + VkAttachmentDescriptionFlags flags + VkFormat format + VkSampleCountFlagBits samples + VkAttachmentLoadOp loadOpLoad operation for color or depth data + VkAttachmentStoreOp storeOpStore operation for color or depth data + VkAttachmentLoadOp stencilLoadOpLoad operation for stencil data + VkAttachmentStoreOp stencilStoreOpStore operation for stencil data + VkImageLayout initialLayout + VkImageLayout finalLayout + + + uint32_t attachment + VkImageLayout layout + + + VkSubpassDescriptionFlags flags + VkPipelineBindPoint pipelineBindPointMust be VK_PIPELINE_BIND_POINT_GRAPHICS for now + uint32_t inputAttachmentCount + const VkAttachmentReference* pInputAttachments + uint32_t colorAttachmentCount + const VkAttachmentReference* pColorAttachments + const VkAttachmentReference* pResolveAttachments + const VkAttachmentReference* pDepthStencilAttachment + uint32_t preserveAttachmentCount + const uint32_t* pPreserveAttachments + + + uint32_t srcSubpass + uint32_t dstSubpass + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + VkDependencyFlags dependencyFlags + + + VkStructureType sType + const void* pNext + VkRenderPassCreateFlags flags + uint32_t attachmentCount + const VkAttachmentDescription* pAttachments + uint32_t subpassCount + const VkSubpassDescription* pSubpasses + uint32_t dependencyCount + const VkSubpassDependency* pDependencies + + + VkStructureType sType + const void* pNext + VkEventCreateFlags flagsEvent creation flags + + + VkStructureType sType + const void* pNext + VkFenceCreateFlags flagsFence creation flags + + + VkBool32 robustBufferAccessout of bounds buffer accesses are well defined + VkBool32 fullDrawIndexUint32full 32-bit range of indices for indexed draw calls + VkBool32 imageCubeArrayimage views which are arrays of cube maps + VkBool32 independentBlendblending operations are controlled per-attachment + VkBool32 geometryShadergeometry stage + VkBool32 tessellationShadertessellation control and evaluation stage + VkBool32 sampleRateShadingper-sample shading and interpolation + VkBool32 dualSrcBlendblend operations which take two sources + VkBool32 logicOplogic operations + VkBool32 multiDrawIndirectmulti draw indirect + VkBool32 drawIndirectFirstInstanceindirect drawing can use non-zero firstInstance + VkBool32 depthClampdepth clamping + VkBool32 depthBiasClampdepth bias clamping + VkBool32 fillModeNonSolidpoint and wireframe fill modes + VkBool32 depthBoundsdepth bounds test + VkBool32 wideLineslines with width greater than 1 + VkBool32 largePointspoints with size greater than 1 + VkBool32 alphaToOnethe fragment alpha component can be forced to maximum representable alpha value + VkBool32 multiViewportviewport arrays + VkBool32 samplerAnisotropyanisotropic sampler filtering + VkBool32 textureCompressionETC2ETC texture compression formats + VkBool32 textureCompressionASTC_LDRASTC LDR texture compression formats + VkBool32 textureCompressionBCBC1-7 texture compressed formats + VkBool32 occlusionQueryPreciseprecise occlusion queries returning actual sample counts + VkBool32 pipelineStatisticsQuerypipeline statistics query + VkBool32 vertexPipelineStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages + VkBool32 fragmentStoresAndAtomicsstores and atomic ops on storage buffers and images are supported in the fragment stage + VkBool32 shaderTessellationAndGeometryPointSizetessellation and geometry stages can export point size + VkBool32 shaderImageGatherExtendedimage gather with run-time values and independent offsets + VkBool32 shaderStorageImageExtendedFormatsthe extended set of formats can be used for storage images + VkBool32 shaderStorageImageMultisamplemultisample images can be used for storage images + VkBool32 shaderStorageImageReadWithoutFormatread from storage image does not require format qualifier + VkBool32 shaderStorageImageWriteWithoutFormatwrite to storage image does not require format qualifier + VkBool32 shaderUniformBufferArrayDynamicIndexingarrays of uniform buffers can be accessed with dynamically uniform indices + VkBool32 shaderSampledImageArrayDynamicIndexingarrays of sampled images can be accessed with dynamically uniform indices + VkBool32 shaderStorageBufferArrayDynamicIndexingarrays of storage buffers can be accessed with dynamically uniform indices + VkBool32 shaderStorageImageArrayDynamicIndexingarrays of storage images can be accessed with dynamically uniform indices + VkBool32 shaderClipDistanceclip distance in shaders + VkBool32 shaderCullDistancecull distance in shaders + VkBool32 shaderFloat6464-bit floats (doubles) in shaders + VkBool32 shaderInt6464-bit integers in shaders + VkBool32 shaderInt1616-bit integers in shaders + VkBool32 shaderResourceResidencyshader can use texture operations that return resource residency information (requires sparseNonResident support) + VkBool32 shaderResourceMinLodshader can use texture operations that specify minimum resource LOD + VkBool32 sparseBindingSparse resources support: Resource memory can be managed at opaque page level rather than object level + VkBool32 sparseResidencyBufferSparse resources support: GPU can access partially resident buffers + VkBool32 sparseResidencyImage2DSparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images + VkBool32 sparseResidencyImage3DSparse resources support: GPU can access partially resident 3D images + VkBool32 sparseResidency2SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 2 samples + VkBool32 sparseResidency4SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 4 samples + VkBool32 sparseResidency8SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 8 samples + VkBool32 sparseResidency16SamplesSparse resources support: GPU can access partially resident MSAA 2D images with 16 samples + VkBool32 sparseResidencyAliasedSparse resources support: GPU can correctly access data aliased into multiple locations (opt-in) + VkBool32 variableMultisampleRatemultisample rate must be the same for all pipelines in a subpass + VkBool32 inheritedQueriesQueries may be inherited from primary to secondary command buffers + + + VkBool32 residencyStandard2DBlockShapeSparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyStandard2DMultisampleBlockShapeSparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyStandard3DBlockShapeSparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format) + VkBool32 residencyAlignedMipSizeSparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail + VkBool32 residencyNonResidentStrictSparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded + + + resource maximum sizes + uint32_t maxImageDimension1Dmax 1D image dimension + uint32_t maxImageDimension2Dmax 2D image dimension + uint32_t maxImageDimension3Dmax 3D image dimension + uint32_t maxImageDimensionCubemax cubemap image dimension + uint32_t maxImageArrayLayersmax layers for image arrays + uint32_t maxTexelBufferElementsmax texel buffer size (fstexels) + uint32_t maxUniformBufferRangemax uniform buffer range (bytes) + uint32_t maxStorageBufferRangemax storage buffer range (bytes) + uint32_t maxPushConstantsSizemax size of the push constants pool (bytes) + memory limits + uint32_t maxMemoryAllocationCountmax number of device memory allocations supported + uint32_t maxSamplerAllocationCountmax number of samplers that can be allocated on a device + VkDeviceSize bufferImageGranularityGranularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage + VkDeviceSize sparseAddressSpaceSizeTotal address space available for sparse allocations (bytes) + descriptor set limits + uint32_t maxBoundDescriptorSetsmax number of descriptors sets that can be bound to a pipeline + uint32_t maxPerStageDescriptorSamplersmax number of samplers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorUniformBuffersmax number of uniform buffers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorStorageBuffersmax number of storage buffers allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorSampledImagesmax number of sampled images allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorStorageImagesmax number of storage images allowed per-stage in a descriptor set + uint32_t maxPerStageDescriptorInputAttachmentsmax number of input attachments allowed per-stage in a descriptor set + uint32_t maxPerStageResourcesmax number of resources allowed by a single stage + uint32_t maxDescriptorSetSamplersmax number of samplers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetUniformBuffersmax number of uniform buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetUniformBuffersDynamicmax number of dynamic uniform buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageBuffersmax number of storage buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageBuffersDynamicmax number of dynamic storage buffers allowed in all stages in a descriptor set + uint32_t maxDescriptorSetSampledImagesmax number of sampled images allowed in all stages in a descriptor set + uint32_t maxDescriptorSetStorageImagesmax number of storage images allowed in all stages in a descriptor set + uint32_t maxDescriptorSetInputAttachmentsmax number of input attachments allowed in all stages in a descriptor set + vertex stage limits + uint32_t maxVertexInputAttributesmax number of vertex input attribute slots + uint32_t maxVertexInputBindingsmax number of vertex input binding slots + uint32_t maxVertexInputAttributeOffsetmax vertex input attribute offset added to vertex buffer offset + uint32_t maxVertexInputBindingStridemax vertex input binding stride + uint32_t maxVertexOutputComponentsmax number of output components written by vertex shader + tessellation control stage limits + uint32_t maxTessellationGenerationLevelmax level supported by tessellation primitive generator + uint32_t maxTessellationPatchSizemax patch size (vertices) + uint32_t maxTessellationControlPerVertexInputComponentsmax number of input components per-vertex in TCS + uint32_t maxTessellationControlPerVertexOutputComponentsmax number of output components per-vertex in TCS + uint32_t maxTessellationControlPerPatchOutputComponentsmax number of output components per-patch in TCS + uint32_t maxTessellationControlTotalOutputComponentsmax total number of per-vertex and per-patch output components in TCS + tessellation evaluation stage limits + uint32_t maxTessellationEvaluationInputComponentsmax number of input components per vertex in TES + uint32_t maxTessellationEvaluationOutputComponentsmax number of output components per vertex in TES + geometry stage limits + uint32_t maxGeometryShaderInvocationsmax invocation count supported in geometry shader + uint32_t maxGeometryInputComponentsmax number of input components read in geometry stage + uint32_t maxGeometryOutputComponentsmax number of output components written in geometry stage + uint32_t maxGeometryOutputVerticesmax number of vertices that can be emitted in geometry stage + uint32_t maxGeometryTotalOutputComponentsmax total number of components (all vertices) written in geometry stage + fragment stage limits + uint32_t maxFragmentInputComponentsmax number of input components read in fragment stage + uint32_t maxFragmentOutputAttachmentsmax number of output attachments written in fragment stage + uint32_t maxFragmentDualSrcAttachmentsmax number of output attachments written when using dual source blending + uint32_t maxFragmentCombinedOutputResourcesmax total number of storage buffers, storage images and output buffers + compute stage limits + uint32_t maxComputeSharedMemorySizemax total storage size of work group local storage (bytes) + uint32_t maxComputeWorkGroupCount[3]max num of compute work groups that may be dispatched by a single command (x,y,z) + uint32_t maxComputeWorkGroupInvocationsmax total compute invocations in a single local work group + uint32_t maxComputeWorkGroupSize[3]max local size of a compute work group (x,y,z) + uint32_t subPixelPrecisionBitsnumber bits of subpixel precision in screen x and y + uint32_t subTexelPrecisionBitsnumber bits of precision for selecting texel weights + uint32_t mipmapPrecisionBitsnumber bits of precision for selecting mipmap weights + uint32_t maxDrawIndexedIndexValuemax index value for indexed draw calls (for 32-bit indices) + uint32_t maxDrawIndirectCountmax draw count for indirect drawing calls + float maxSamplerLodBiasmax absolute sampler LOD bias + float maxSamplerAnisotropymax degree of sampler anisotropy + uint32_t maxViewportsmax number of active viewports + uint32_t maxViewportDimensions[2]max viewport dimensions (x,y) + float viewportBoundsRange[2]viewport bounds range (min,max) + uint32_t viewportSubPixelBitsnumber bits of subpixel precision for viewport + size_t minMemoryMapAlignmentmin required alignment of pointers returned by MapMemory (bytes) + VkDeviceSize minTexelBufferOffsetAlignmentmin required alignment for texel buffer offsets (bytes) + VkDeviceSize minUniformBufferOffsetAlignmentmin required alignment for uniform buffer sizes and offsets (bytes) + VkDeviceSize minStorageBufferOffsetAlignmentmin required alignment for storage buffer offsets (bytes) + int32_t minTexelOffsetmin texel offset for OpTextureSampleOffset + uint32_t maxTexelOffsetmax texel offset for OpTextureSampleOffset + int32_t minTexelGatherOffsetmin texel offset for OpTextureGatherOffset + uint32_t maxTexelGatherOffsetmax texel offset for OpTextureGatherOffset + float minInterpolationOffsetfurthest negative offset for interpolateAtOffset + float maxInterpolationOffsetfurthest positive offset for interpolateAtOffset + uint32_t subPixelInterpolationOffsetBitsnumber of subpixel bits for interpolateAtOffset + uint32_t maxFramebufferWidthmax width for a framebuffer + uint32_t maxFramebufferHeightmax height for a framebuffer + uint32_t maxFramebufferLayersmax layer count for a layered framebuffer + VkSampleCountFlags framebufferColorSampleCountssupported color sample counts for a framebuffer + VkSampleCountFlags framebufferDepthSampleCountssupported depth sample counts for a framebuffer + VkSampleCountFlags framebufferStencilSampleCountssupported stencil sample counts for a framebuffer + VkSampleCountFlags framebufferNoAttachmentsSampleCountssupported sample counts for a subpass which uses no attachments + uint32_t maxColorAttachmentsmax number of color attachments per subpass + VkSampleCountFlags sampledImageColorSampleCountssupported color sample counts for a non-integer sampled image + VkSampleCountFlags sampledImageIntegerSampleCountssupported sample counts for an integer image + VkSampleCountFlags sampledImageDepthSampleCountssupported depth sample counts for a sampled image + VkSampleCountFlags sampledImageStencilSampleCountssupported stencil sample counts for a sampled image + VkSampleCountFlags storageImageSampleCountssupported sample counts for a storage image + uint32_t maxSampleMaskWordsmax number of sample mask words + VkBool32 timestampComputeAndGraphicstimestamps on graphics and compute queues + float timestampPeriodnumber of nanoseconds it takes for timestamp query value to increment by 1 + uint32_t maxClipDistancesmax number of clip distances + uint32_t maxCullDistancesmax number of cull distances + uint32_t maxCombinedClipAndCullDistancesmax combined number of user clipping + uint32_t discreteQueuePrioritiesdistinct queue priorities available + float pointSizeRange[2]range (min,max) of supported point sizes + float lineWidthRange[2]range (min,max) of supported line widths + float pointSizeGranularitygranularity of supported point sizes + float lineWidthGranularitygranularity of supported line widths + VkBool32 strictLinesline rasterization follows preferred rules + VkBool32 standardSampleLocationssupports standard sample locations for all supported sample counts + VkDeviceSize optimalBufferCopyOffsetAlignmentoptimal offset of buffer copies + VkDeviceSize optimalBufferCopyRowPitchAlignmentoptimal pitch of buffer copies + VkDeviceSize nonCoherentAtomSizeminimum size and alignment for non-coherent host-mapped device memory access + + + VkStructureType sType + const void* pNext + VkSemaphoreCreateFlags flagsSemaphore creation flags + + + VkStructureType sType + const void* pNext + VkQueryPoolCreateFlags flags + VkQueryType queryType + uint32_t queryCount + VkQueryPipelineStatisticFlags pipelineStatisticsOptional + + + VkStructureType sType + const void* pNext + VkFramebufferCreateFlags flags + VkRenderPass renderPass + uint32_t attachmentCount + const VkImageView* pAttachments + uint32_t width + uint32_t height + uint32_t layers + + + uint32_t vertexCount + uint32_t instanceCount + uint32_t firstVertex + uint32_t firstInstance + + + uint32_t indexCount + uint32_t instanceCount + uint32_t firstIndex + int32_t vertexOffset + uint32_t firstInstance + + + uint32_t x + uint32_t y + uint32_t z + + + uint32_t firstVertex + uint32_t vertexCount + + + uint32_t firstIndex + uint32_t indexCount + int32_t vertexOffset + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + const VkPipelineStageFlags* pWaitDstStageMask + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + uint32_t signalSemaphoreCount + const VkSemaphore* pSignalSemaphores + + WSI extensions + + VkDisplayKHR displayHandle of the display object + const char* displayNameName of the display + VkExtent2D physicalDimensionsIn millimeters? + VkExtent2D physicalResolutionMax resolution for CRT? + VkSurfaceTransformFlagsKHR supportedTransformsone or more bits from VkSurfaceTransformFlagsKHR + VkBool32 planeReorderPossibleVK_TRUE if the overlay plane's z-order can be changed on this display. + VkBool32 persistentContentVK_TRUE if this is a "smart" display that supports self-refresh/internal buffering. + + + VkDisplayKHR currentDisplayDisplay the plane is currently associated with. Will be VK_NULL_HANDLE if the plane is not in use. + uint32_t currentStackIndexCurrent z-order of the plane. + + + VkExtent2D visibleRegionVisible scanout region. + uint32_t refreshRateNumber of times per second the display is updated. + + + VkDisplayModeKHR displayModeHandle of this display mode. + VkDisplayModeParametersKHR parametersThe parameters this mode uses. + + + VkStructureType sType + const void* pNext + VkDisplayModeCreateFlagsKHR flags + VkDisplayModeParametersKHR parametersThe parameters this mode uses. + + + VkDisplayPlaneAlphaFlagsKHR supportedAlphaTypes of alpha blending supported, if any. + VkOffset2D minSrcPositionDoes the plane have any position and extent restrictions? + VkOffset2D maxSrcPosition + VkExtent2D minSrcExtent + VkExtent2D maxSrcExtent + VkOffset2D minDstPosition + VkOffset2D maxDstPosition + VkExtent2D minDstExtent + VkExtent2D maxDstExtent + + + VkStructureType sType + const void* pNext + VkDisplaySurfaceCreateFlagsKHR flags + VkDisplayModeKHR displayModeThe mode to use when displaying this surface + uint32_t planeIndexThe plane on which this surface appears. Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount. + uint32_t planeStackIndexThe z-order of the plane. + VkSurfaceTransformFlagBitsKHR transformTransform to apply to the images as part of the scanout operation + float globalAlphaGlobal alpha value. Must be between 0 and 1, inclusive. Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR + VkDisplayPlaneAlphaFlagBitsKHR alphaModeWhat type of alpha blending to use. Must be a bit from vkGetDisplayPlanePropertiesKHR::supportedAlpha. + VkExtent2D imageExtentsize of the images to use with this surface + + + VkStructureType sType + const void* pNext + VkRect2D srcRectRectangle within the presentable image to read pixel data from when presenting to the display. + VkRect2D dstRectRectangle within the current display mode's visible region to display srcRectangle in. + VkBool32 persistentFor smart displays, use buffered mode. If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE. + + + uint32_t minImageCountSupported minimum number of images for the surface + uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited + VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined + VkExtent2D minImageExtentSupported minimum image width and height for the surface + VkExtent2D maxImageExtentSupported maximum image width and height for the surface + uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface + VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported + VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation + VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported + VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface + + + VkStructureType sType + const void* pNext + VkAndroidSurfaceCreateFlagsKHR flags + struct ANativeWindow* window + + + VkStructureType sType + const void* pNext + VkViSurfaceCreateFlagsNN flags + void* window + + + VkStructureType sType + const void* pNext + VkWaylandSurfaceCreateFlagsKHR flags + struct wl_display* display + struct wl_surface* surface + + + VkStructureType sType + const void* pNext + VkWin32SurfaceCreateFlagsKHR flags + HINSTANCE hinstance + HWND hwnd + + + VkStructureType sType + const void* pNext + VkXlibSurfaceCreateFlagsKHR flags + Display* dpy + Window window + + + VkStructureType sType + const void* pNext + VkXcbSurfaceCreateFlagsKHR flags + xcb_connection_t* connection + xcb_window_t window + + + VkStructureType sType + const void* pNext + VkDirectFBSurfaceCreateFlagsEXT flags + IDirectFB* dfb + IDirectFBSurface* surface + + + VkStructureType sType + const void* pNext + VkImagePipeSurfaceCreateFlagsFUCHSIA flags + zx_handle_t imagePipeHandle + + + VkStructureType sType + const void* pNext + VkStreamDescriptorSurfaceCreateFlagsGGP flags + GgpStreamDescriptor streamDescriptor + + + VkStructureType sType + const void* pNext + VkScreenSurfaceCreateFlagsQNX flags + struct _screen_context* context + struct _screen_window* window + + + VkFormat formatSupported pair of rendering format + VkColorSpaceKHR colorSpaceand color space for the surface + + + VkStructureType sType + const void* pNext + VkSwapchainCreateFlagsKHR flags + VkSurfaceKHR surfaceThe swapchain's target surface + uint32_t minImageCountMinimum number of presentation images the application needs + VkFormat imageFormatFormat of the presentation images + VkColorSpaceKHR imageColorSpaceColorspace of the presentation images + VkExtent2D imageExtentDimensions of the presentation images + uint32_t imageArrayLayersDetermines the number of views for multiview/stereo presentation + VkImageUsageFlags imageUsageBits indicating how the presentation images will be used + VkSharingMode imageSharingModeSharing mode used for the presentation images + uint32_t queueFamilyIndexCountNumber of queue families having access to the images in case of concurrent sharing mode + const uint32_t* pQueueFamilyIndicesArray of queue family indices having access to the images in case of concurrent sharing mode + VkSurfaceTransformFlagBitsKHR preTransformThe transform, relative to the device's natural orientation, applied to the image content prior to presentation + VkCompositeAlphaFlagBitsKHR compositeAlphaThe alpha blending mode used when compositing this surface with other surfaces in the window system + VkPresentModeKHR presentModeWhich presentation mode to use for presents on this swap chain + VkBool32 clippedSpecifies whether presentable images may be affected by window clip regions + VkSwapchainKHR oldSwapchainExisting swap chain to replace, if any + VkSwapchainKHR oldSwapchainExisting swap chain to replace, if any + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCountNumber of semaphores to wait for before presenting + const VkSemaphore* pWaitSemaphoresSemaphores to wait for before presenting + uint32_t swapchainCountNumber of swapchains to present in this call + const VkSwapchainKHR* pSwapchainsSwapchains to present an image from + const uint32_t* pImageIndicesIndices of which presentable images to present + VkResult* pResultsOptional (i.e. if non-NULL) VkResult for each swapchain + + + VkStructureType sType + const void* pNext + VkDebugReportFlagsEXT flagsIndicates which events call this callback + PFN_vkDebugReportCallbackEXT pfnCallbackFunction pointer of a callback function + void* pUserDataUser data provided to callback function + + + VkStructureType sTypeMust be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT + const void* pNext + uint32_t disabledValidationCheckCountNumber of validation checks to disable + const VkValidationCheckEXT* pDisabledValidationChecksValidation checks to disable + + + VkStructureType sTypeMust be VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT + const void* pNext + uint32_t enabledValidationFeatureCountNumber of validation features to enable + const VkValidationFeatureEnableEXT* pEnabledValidationFeaturesValidation features to enable + uint32_t disabledValidationFeatureCountNumber of validation features to disable + const VkValidationFeatureDisableEXT* pDisabledValidationFeaturesValidation features to disable + + + VkStructureType sType + const void* pNext + uint32_t vendorID + uint32_t deviceID + uint32_t key + uint64_t value + + + VkStructureType sType + const void* pNext + VkRasterizationOrderAMD rasterizationOrderRasterization order to use for the pipeline + + + VkStructureType sType + const void* pNext + VkDebugReportObjectTypeEXT objectTypeThe type of the object + uint64_t objectThe handle of the object, cast to uint64_t + const char* pObjectNameName to apply to the object + + + VkStructureType sType + const void* pNext + VkDebugReportObjectTypeEXT objectTypeThe type of the object + uint64_t objectThe handle of the object, cast to uint64_t + uint64_t tagNameThe name of the tag to set on the object + size_t tagSizeThe length in bytes of the tag data + const void* pTagTag data to attach to the object + + + VkStructureType sType + const void* pNext + const char* pMarkerNameName of the debug marker + float color[4]Optional color for debug marker + + + VkStructureType sType + const void* pNext + VkBool32 dedicatedAllocationWhether this image uses a dedicated allocation + + + VkStructureType sType + const void* pNext + VkBool32 dedicatedAllocationWhether this buffer uses a dedicated allocation + + + VkStructureType sType + const void* pNext + VkImage imageImage that this allocation will be bound to + VkBuffer bufferBuffer that this allocation will be bound to + + + VkImageFormatProperties imageFormatProperties + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleTypes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagsNV handleType + HANDLE handle + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + + + VkStructureType sType + const void* pNext + NvSciBufAttrList pAttributes + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + NvSciBufObj handle + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + void* pNext + VkBool32 sciBufImport + VkBool32 sciBufExport + + + + VkStructureType sType + const void* pNext + uint32_t acquireCount + const VkDeviceMemory* pAcquireSyncs + const uint64_t* pAcquireKeys + const uint32_t* pAcquireTimeoutMilliseconds + uint32_t releaseCount + const VkDeviceMemory* pReleaseSyncs + const uint64_t* pReleaseKeys + + + VkStructureType sType + void* pNext + VkBool32 deviceGeneratedCommands + + + VkStructureType sType + const void* pNext + uint32_t privateDataSlotRequestCount + + + + VkStructureType sType + const void* pNext + VkPrivateDataSlotCreateFlags flags + + + + VkStructureType sType + void* pNext + VkBool32 privateData + + + + VkStructureType sType + void* pNext + uint32_t maxGraphicsShaderGroupCount + uint32_t maxIndirectSequenceCount + uint32_t maxIndirectCommandsTokenCount + uint32_t maxIndirectCommandsStreamCount + uint32_t maxIndirectCommandsTokenOffset + uint32_t maxIndirectCommandsStreamStride + uint32_t minSequencesCountBufferOffsetAlignment + uint32_t minSequencesIndexBufferOffsetAlignment + uint32_t minIndirectCommandsBufferOffsetAlignment + + + VkStructureType sType + void* pNext + uint32_t maxMultiDrawCount + + + VkStructureType sType + const void* pNext + uint32_t stageCount + const VkPipelineShaderStageCreateInfo* pStages + const VkPipelineVertexInputStateCreateInfo* pVertexInputState + const VkPipelineTessellationStateCreateInfo* pTessellationState + + + VkStructureType sType + const void* pNext + uint32_t groupCount + const VkGraphicsShaderGroupCreateInfoNV* pGroups + uint32_t pipelineCount + const VkPipeline* pPipelines + + + uint32_t groupIndex + + + VkDeviceAddress bufferAddress + uint32_t size + VkIndexType indexType + + + VkDeviceAddress bufferAddress + uint32_t size + uint32_t stride + + + uint32_t data + + + VkBuffer buffer + VkDeviceSize offset + + + VkStructureType sType + const void* pNext + VkIndirectCommandsTokenTypeNV tokenType + uint32_t stream + uint32_t offset + uint32_t vertexBindingUnit + VkBool32 vertexDynamicStride + VkPipelineLayout pushconstantPipelineLayout + VkShaderStageFlags pushconstantShaderStageFlags + uint32_t pushconstantOffset + uint32_t pushconstantSize + VkIndirectStateFlagsNV indirectStateFlags + uint32_t indexTypeCount + const VkIndexType* pIndexTypes + const uint32_t* pIndexTypeValues + + + VkStructureType sType + const void* pNext + VkIndirectCommandsLayoutUsageFlagsNV flags + VkPipelineBindPoint pipelineBindPoint + uint32_t tokenCount + const VkIndirectCommandsLayoutTokenNV* pTokens + uint32_t streamCount + const uint32_t* pStreamStrides + + + VkStructureType sType + const void* pNext + VkPipelineBindPoint pipelineBindPoint + VkPipeline pipeline + VkIndirectCommandsLayoutNV indirectCommandsLayout + uint32_t streamCount + const VkIndirectCommandsStreamNV* pStreams + uint32_t sequencesCount + VkBuffer preprocessBuffer + VkDeviceSize preprocessOffset + VkDeviceSize preprocessSize + VkBuffer sequencesCountBuffer + VkDeviceSize sequencesCountOffset + VkBuffer sequencesIndexBuffer + VkDeviceSize sequencesIndexOffset + + + VkStructureType sType + const void* pNext + VkPipelineBindPoint pipelineBindPoint + VkPipeline pipeline + VkIndirectCommandsLayoutNV indirectCommandsLayout + uint32_t maxSequencesCount + + + VkStructureType sType + void* pNext + VkPhysicalDeviceFeatures features + + + + VkStructureType sType + void* pNext + VkPhysicalDeviceProperties properties + + + + VkStructureType sType + void* pNext + VkFormatProperties formatProperties + + + + VkStructureType sType + void* pNext + VkImageFormatProperties imageFormatProperties + + + + VkStructureType sType + const void* pNext + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + + + + VkStructureType sType + void* pNext + VkQueueFamilyProperties queueFamilyProperties + + + + VkStructureType sType + void* pNext + VkPhysicalDeviceMemoryProperties memoryProperties + + + + VkStructureType sType + void* pNext + VkSparseImageFormatProperties properties + + + + VkStructureType sType + const void* pNext + VkFormat format + VkImageType type + VkSampleCountFlagBits samples + VkImageUsageFlags usage + VkImageTiling tiling + + + + VkStructureType sType + void* pNext + uint32_t maxPushDescriptors + + + uint8_t major + uint8_t minor + uint8_t subminor + uint8_t patch + + + + VkStructureType sType + void* pNext + VkDriverId driverID + char driverName[VK_MAX_DRIVER_NAME_SIZE] + char driverInfo[VK_MAX_DRIVER_INFO_SIZE] + VkConformanceVersion conformanceVersion + + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const VkPresentRegionKHR* pRegionsThe regions that have changed + + + uint32_t rectangleCountNumber of rectangles in pRectangles + const VkRectLayerKHR* pRectanglesArray of rectangles that have changed in a swapchain's image(s) + + + VkOffset2D offsetupper-left corner of a rectangle that has not changed, in pixels of a presentation images + VkExtent2D extentDimensions of a rectangle that has not changed, in pixels of a presentation images + uint32_t layerLayer of a swapchain's image(s), for stereoscopic-3D images + + + VkStructureType sType + void* pNext + VkBool32 variablePointersStorageBuffer + VkBool32 variablePointers + + + + + + VkExternalMemoryFeatureFlags externalMemoryFeatures + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes + VkExternalMemoryHandleTypeFlags compatibleHandleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalMemoryProperties externalMemoryProperties + + + + VkStructureType sType + const void* pNext + VkBufferCreateFlags flags + VkBufferUsageFlags usage + VkExternalMemoryHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalMemoryProperties externalMemoryProperties + + + + VkStructureType sType + void* pNext + uint8_t deviceUUID[VK_UUID_SIZE] + uint8_t driverUUID[VK_UUID_SIZE] + uint8_t deviceLUID[VK_LUID_SIZE] + uint32_t deviceNodeMask + VkBool32 deviceLUIDValid + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + zx_handle_t handle + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + uint32_t acquireCount + const VkDeviceMemory* pAcquireSyncs + const uint64_t* pAcquireKeys + const uint32_t* pAcquireTimeouts + uint32_t releaseCount + const VkDeviceMemory* pReleaseSyncs + const uint64_t* pReleaseKeys + + + VkStructureType sType + const void* pNext + VkExternalSemaphoreHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures + + + + VkStructureType sType + const void* pNext + VkExternalSemaphoreHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkSemaphoreImportFlags flags + VkExternalSemaphoreHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreValuesCount + const uint64_t* pWaitSemaphoreValues + uint32_t signalSemaphoreValuesCount + const uint64_t* pSignalSemaphoreValues + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkSemaphoreImportFlags flags + VkExternalSemaphoreHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkSemaphoreImportFlags flags + VkExternalSemaphoreHandleTypeFlagBits handleType + zx_handle_t zirconHandle + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkExternalFenceHandleTypeFlagBits handleType + + + + VkStructureType sType + void* pNext + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes + VkExternalFenceHandleTypeFlags compatibleHandleTypes + VkExternalFenceFeatureFlags externalFenceFeatures + + + + VkStructureType sType + const void* pNext + VkExternalFenceHandleTypeFlags handleTypes + + + + VkStructureType sType + const void* pNext + VkFence fence + VkFenceImportFlags flags + VkExternalFenceHandleTypeFlagBits handleType + HANDLE handle + LPCWSTR name + + + VkStructureType sType + const void* pNext + const SECURITY_ATTRIBUTES* pAttributes + DWORD dwAccess + LPCWSTR name + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkFence fence + VkFenceImportFlags flags + VkExternalFenceHandleTypeFlagBits handleType + int fd + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + NvSciSyncAttrList pAttributes + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBits handleType + void* handle + + + VkStructureType sType + const void* pNext + VkFence fence + VkExternalFenceHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + NvSciSyncAttrList pAttributes + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + void* handle + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkExternalSemaphoreHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkSciSyncClientTypeNV clientType + VkSciSyncPrimitiveTypeNV primitiveType + + + VkStructureType sType + void* pNext + VkBool32 sciSyncFence + VkBool32 sciSyncSemaphore + VkBool32 sciSyncImport + VkBool32 sciSyncExport + + + VkStructureType sType + void* pNext + VkBool32 sciSyncFence + VkBool32 sciSyncSemaphore2 + VkBool32 sciSyncImport + VkBool32 sciSyncExport + + + VkStructureType sType + const void* pNext + NvSciSyncObj handle + + + VkStructureType sType + const void* pNext + VkSemaphoreSciSyncPoolNV semaphorePool + const NvSciSyncFence* pFence + + + VkStructureType sType + const void* pNext + uint32_t semaphoreSciSyncPoolRequestCount + + + VkStructureType sType + void* pNext + VkBool32 multiviewMultiple views in a renderpass + VkBool32 multiviewGeometryShaderMultiple views in a renderpass w/ geometry shader + VkBool32 multiviewTessellationShaderMultiple views in a renderpass w/ tessellation shader + + + + VkStructureType sType + void* pNext + uint32_t maxMultiviewViewCountmax number of views in a subpass + uint32_t maxMultiviewInstanceIndexmax instance index for a draw in a multiview subpass + + + + VkStructureType sType + const void* pNext + uint32_t subpassCount + const uint32_t* pViewMasks + uint32_t dependencyCount + const int32_t* pViewOffsets + uint32_t correlationMaskCount + const uint32_t* pCorrelationMasks + + + + VkStructureType sType + void* pNext + uint32_t minImageCountSupported minimum number of images for the surface + uint32_t maxImageCountSupported maximum number of images for the surface, 0 for unlimited + VkExtent2D currentExtentCurrent image width and height for the surface, (0, 0) if undefined + VkExtent2D minImageExtentSupported minimum image width and height for the surface + VkExtent2D maxImageExtentSupported maximum image width and height for the surface + uint32_t maxImageArrayLayersSupported maximum number of image layers for the surface + VkSurfaceTransformFlagsKHR supportedTransforms1 or more bits representing the transforms supported + VkSurfaceTransformFlagBitsKHR currentTransformThe surface's current transform relative to the device's natural orientation + VkCompositeAlphaFlagsKHR supportedCompositeAlpha1 or more bits representing the alpha compositing modes supported + VkImageUsageFlags supportedUsageFlagsSupported image usage flags for the surface + VkSurfaceCounterFlagsEXT supportedSurfaceCounters + + + VkStructureType sType + const void* pNext + VkDisplayPowerStateEXT powerState + + + VkStructureType sType + const void* pNext + VkDeviceEventTypeEXT deviceEvent + + + VkStructureType sType + const void* pNext + VkDisplayEventTypeEXT displayEvent + + + VkStructureType sType + const void* pNext + VkSurfaceCounterFlagsEXT surfaceCounters + + + VkStructureType sType + void* pNext + uint32_t physicalDeviceCount + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE] + VkBool32 subsetAllocation + + + + VkStructureType sType + const void* pNext + VkMemoryAllocateFlags flags + uint32_t deviceMask + + + + VkStructureType sType + const void* pNext + VkBuffer buffer + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + + VkStructureType sType + const void* pNext + uint32_t deviceIndexCount + const uint32_t* pDeviceIndices + + + + VkStructureType sType + const void* pNext + VkImage image + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + + VkStructureType sType + const void* pNext + uint32_t deviceIndexCount + const uint32_t* pDeviceIndices + uint32_t splitInstanceBindRegionCount + const VkRect2D* pSplitInstanceBindRegions + + + + VkStructureType sType + const void* pNext + uint32_t deviceMask + uint32_t deviceRenderAreaCount + const VkRect2D* pDeviceRenderAreas + + + + VkStructureType sType + const void* pNext + uint32_t deviceMask + + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const uint32_t* pWaitSemaphoreDeviceIndices + uint32_t commandBufferCount + const uint32_t* pCommandBufferDeviceMasks + uint32_t signalSemaphoreCount + const uint32_t* pSignalSemaphoreDeviceIndices + + + + VkStructureType sType + const void* pNext + uint32_t resourceDeviceIndex + uint32_t memoryDeviceIndex + + + + VkStructureType sType + void* pNext + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE] + VkDeviceGroupPresentModeFlagsKHR modes + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + uint32_t imageIndex + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchain + uint64_t timeout + VkSemaphore semaphore + VkFence fence + uint32_t deviceMask + + + VkStructureType sType + const void* pNext + uint32_t swapchainCount + const uint32_t* pDeviceMasks + VkDeviceGroupPresentModeFlagBitsKHR mode + + + VkStructureType sType + const void* pNext + uint32_t physicalDeviceCount + const VkPhysicalDevice* pPhysicalDevices + + + + VkStructureType sType + const void* pNext + VkDeviceGroupPresentModeFlagsKHR modes + + + uint32_t dstBindingBinding within the destination descriptor set to write + uint32_t dstArrayElementArray element within the destination binding to write + uint32_t descriptorCountNumber of descriptors to write + VkDescriptorType descriptorTypeDescriptor type to write + size_t offsetOffset into pData where the descriptors to update are stored + size_t strideStride between two descriptors in pData when writing more than one descriptor + + + + VkStructureType sType + const void* pNext + VkDescriptorUpdateTemplateCreateFlags flags + uint32_t descriptorUpdateEntryCountNumber of descriptor update entries to use for the update template + const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntriesDescriptor update entries for the template + VkDescriptorUpdateTemplateType templateType + VkDescriptorSetLayout descriptorSetLayout + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout pipelineLayoutIf used for push descriptors, this is the only allowed layout + uint32_t set + + + + float x + float y + + + VkStructureType sType + void* pNext + VkBool32 presentIdPresent ID in VkPresentInfoKHR + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const uint64_t* pPresentIdsPresent ID values for each swapchain + + + VkStructureType sType + void* pNext + VkBool32 presentWaitvkWaitForPresentKHR is supported + + + Display primary in chromaticity coordinates + VkStructureType sType + const void* pNext + From SMPTE 2086 + VkXYColorEXT displayPrimaryRedDisplay primary's Red + VkXYColorEXT displayPrimaryGreenDisplay primary's Green + VkXYColorEXT displayPrimaryBlueDisplay primary's Blue + VkXYColorEXT whitePointDisplay primary's Blue + float maxLuminanceDisplay maximum luminance + float minLuminanceDisplay minimum luminance + From CTA 861.3 + float maxContentLightLevelContent maximum luminance + float maxFrameAverageLightLevel + + + VkStructureType sType + void* pNext + VkBool32 localDimmingSupport + + + VkStructureType sType + const void* pNext + VkBool32 localDimmingEnable + + + uint64_t refreshDurationNumber of nanoseconds from the start of one refresh cycle to the next + + + uint32_t presentIDApplication-provided identifier, previously given to vkQueuePresentKHR + uint64_t desiredPresentTimeEarliest time an image should have been presented, previously given to vkQueuePresentKHR + uint64_t actualPresentTimeTime the image was actually displayed + uint64_t earliestPresentTimeEarliest time the image could have been displayed + uint64_t presentMarginHow early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const VkPresentTimeGOOGLE* pTimesThe earliest times to present images + + + uint32_t presentIDApplication-provided identifier + uint64_t desiredPresentTimeEarliest time an image should be presented + + + VkStructureType sType + const void* pNext + VkIOSSurfaceCreateFlagsMVK flags + const void* pView + + + VkStructureType sType + const void* pNext + VkMacOSSurfaceCreateFlagsMVK flags + const void* pView + + + VkStructureType sType + const void* pNext + VkMetalSurfaceCreateFlagsEXT flags + const CAMetalLayer* pLayer + + + float xcoeff + float ycoeff + + + VkStructureType sType + const void* pNext + VkBool32 viewportWScalingEnable + uint32_t viewportCount + const VkViewportWScalingNV* pViewportWScalings + + + VkViewportCoordinateSwizzleNV x + VkViewportCoordinateSwizzleNV y + VkViewportCoordinateSwizzleNV z + VkViewportCoordinateSwizzleNV w + + + VkStructureType sType + const void* pNext + VkPipelineViewportSwizzleStateCreateFlagsNV flags + uint32_t viewportCount + const VkViewportSwizzleNV* pViewportSwizzles + + + VkStructureType sType + void* pNext + uint32_t maxDiscardRectanglesmax number of active discard rectangles + + + VkStructureType sType + const void* pNext + VkPipelineDiscardRectangleStateCreateFlagsEXT flags + VkDiscardRectangleModeEXT discardRectangleMode + uint32_t discardRectangleCount + const VkRect2D* pDiscardRectangles + + + VkStructureType sType + void* pNext + VkBool32 perViewPositionAllComponents + + + uint32_t subpass + uint32_t inputAttachmentIndex + VkImageAspectFlags aspectMask + + + + VkStructureType sType + const void* pNext + uint32_t aspectReferenceCount + const VkInputAttachmentAspectReference* pAspectReferences + + + + VkStructureType sType + const void* pNext + VkSurfaceKHR surface + + + VkStructureType sType + void* pNext + VkSurfaceCapabilitiesKHR surfaceCapabilities + + + VkStructureType sType + void* pNext + VkSurfaceFormatKHR surfaceFormat + + + VkStructureType sType + void* pNext + VkDisplayPropertiesKHR displayProperties + + + VkStructureType sType + void* pNext + VkDisplayPlanePropertiesKHR displayPlaneProperties + + + VkStructureType sType + void* pNext + VkDisplayModePropertiesKHR displayModeProperties + + + VkStructureType sType + const void* pNext + VkDisplayModeKHR mode + uint32_t planeIndex + + + VkStructureType sType + void* pNext + VkDisplayPlaneCapabilitiesKHR capabilities + + + VkStructureType sType + void* pNext + VkImageUsageFlags sharedPresentSupportedUsageFlagsSupported image usage flags if swapchain created using a shared present mode + + + VkStructureType sType + void* pNext + VkBool32 storageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock + VkBool32 uniformAndStorageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock and Block + VkBool32 storagePushConstant1616-bit integer/floating-point variables supported in PushConstant + VkBool32 storageInputOutput1616-bit integer/floating-point variables supported in shader inputs and outputs + + + + VkStructureType sType + void* pNext + uint32_t subgroupSizeThe size of a subgroup for this queue. + VkShaderStageFlags supportedStagesBitfield of what shader stages support subgroup operations + VkSubgroupFeatureFlags supportedOperationsBitfield of what subgroup operations are supported. + VkBool32 quadOperationsInAllStagesFlag to specify whether quad operations are available in all stages. + + + VkStructureType sType + void* pNext + VkBool32 shaderSubgroupExtendedTypesFlag to specify whether subgroup operations with extended types are supported + + + + VkStructureType sType + const void* pNext + VkBuffer buffer + + + + VkStructureType sType + const void* pNext + const VkBufferCreateInfo* pCreateInfo + + + + VkStructureType sType + const void* pNext + VkImage image + + + + VkStructureType sType + const void* pNext + VkImage image + + + + VkStructureType sType + const void* pNext + const VkImageCreateInfo* pCreateInfo + VkImageAspectFlagBits planeAspect + + + + VkStructureType sType + void* pNext + VkMemoryRequirements memoryRequirements + + + + VkStructureType sType + void* pNext + VkSparseImageMemoryRequirements memoryRequirements + + + + VkStructureType sType + void* pNext + VkPointClippingBehavior pointClippingBehavior + + + + VkStructureType sType + void* pNext + VkBool32 prefersDedicatedAllocation + VkBool32 requiresDedicatedAllocation + + + + VkStructureType sType + const void* pNext + VkImage imageImage that this allocation will be bound to + VkBuffer bufferBuffer that this allocation will be bound to + + + + VkStructureType sType + const void* pNext + VkImageUsageFlags usage + + + VkStructureType sType + const void* pNext + uint32_t sliceOffset + uint32_t sliceCount + + + + VkStructureType sType + const void* pNext + VkTessellationDomainOrigin domainOrigin + + + + VkStructureType sType + const void* pNext + VkSamplerYcbcrConversion conversion + + + + VkStructureType sType + const void* pNext + VkFormat format + VkSamplerYcbcrModelConversion ycbcrModel + VkSamplerYcbcrRange ycbcrRange + VkComponentMapping components + VkChromaLocation xChromaOffset + VkChromaLocation yChromaOffset + VkFilter chromaFilter + VkBool32 forceExplicitReconstruction + + + + VkStructureType sType + const void* pNext + VkImageAspectFlagBits planeAspect + + + + VkStructureType sType + const void* pNext + VkImageAspectFlagBits planeAspect + + + + VkStructureType sType + void* pNext + VkBool32 samplerYcbcrConversionSampler color conversion supported + + + + VkStructureType sType + void* pNext + uint32_t combinedImageSamplerDescriptorCount + + + + VkStructureType sType + void* pNext + VkBool32 supportsTextureGatherLODBiasAMD + + + VkStructureType sType + const void* pNext + VkBuffer buffer + VkDeviceSize offset + VkConditionalRenderingFlagsEXT flags + + + VkStructureType sType + const void* pNext + VkBool32 protectedSubmitSubmit protected command buffers + + + VkStructureType sType + void* pNext + VkBool32 protectedMemory + + + VkStructureType sType + void* pNext + VkBool32 protectedNoFault + + + VkStructureType sType + const void* pNext + VkDeviceQueueCreateFlags flags + uint32_t queueFamilyIndex + uint32_t queueIndex + + + VkStructureType sType + const void* pNext + VkPipelineCoverageToColorStateCreateFlagsNV flags + VkBool32 coverageToColorEnable + uint32_t coverageToColorLocation + + + VkStructureType sType + void* pNext + VkBool32 filterMinmaxSingleComponentFormats + VkBool32 filterMinmaxImageComponentMapping + + + + float x + float y + + + VkStructureType sType + const void* pNext + VkSampleCountFlagBits sampleLocationsPerPixel + VkExtent2D sampleLocationGridSize + uint32_t sampleLocationsCount + const VkSampleLocationEXT* pSampleLocations + + + uint32_t attachmentIndex + VkSampleLocationsInfoEXT sampleLocationsInfo + + + uint32_t subpassIndex + VkSampleLocationsInfoEXT sampleLocationsInfo + + + VkStructureType sType + const void* pNext + uint32_t attachmentInitialSampleLocationsCount + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations + uint32_t postSubpassSampleLocationsCount + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations + + + VkStructureType sType + const void* pNext + VkBool32 sampleLocationsEnable + VkSampleLocationsInfoEXT sampleLocationsInfo + + + VkStructureType sType + void* pNext + VkSampleCountFlags sampleLocationSampleCounts + VkExtent2D maxSampleLocationGridSize + float sampleLocationCoordinateRange[2] + uint32_t sampleLocationSubPixelBits + VkBool32 variableSampleLocations + + + VkStructureType sType + void* pNext + VkExtent2D maxSampleLocationGridSize + + + VkStructureType sType + const void* pNext + VkSamplerReductionMode reductionMode + + + + VkStructureType sType + void* pNext + VkBool32 advancedBlendCoherentOperations + + + VkStructureType sType + void* pNext + VkBool32 multiDraw + + + VkStructureType sType + void* pNext + uint32_t advancedBlendMaxColorAttachments + VkBool32 advancedBlendIndependentBlend + VkBool32 advancedBlendNonPremultipliedSrcColor + VkBool32 advancedBlendNonPremultipliedDstColor + VkBool32 advancedBlendCorrelatedOverlap + VkBool32 advancedBlendAllOperations + + + VkStructureType sType + const void* pNext + VkBool32 srcPremultiplied + VkBool32 dstPremultiplied + VkBlendOverlapEXT blendOverlap + + + VkStructureType sType + void* pNext + VkBool32 inlineUniformBlock + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind + + + + VkStructureType sType + void* pNext + uint32_t maxInlineUniformBlockSize + uint32_t maxPerStageDescriptorInlineUniformBlocks + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks + uint32_t maxDescriptorSetInlineUniformBlocks + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks + + + + VkStructureType sType + const void* pNext + uint32_t dataSize + const void* pData + + + + VkStructureType sType + const void* pNext + uint32_t maxInlineUniformBlockBindings + + + + VkStructureType sType + const void* pNext + VkPipelineCoverageModulationStateCreateFlagsNV flags + VkCoverageModulationModeNV coverageModulationMode + VkBool32 coverageModulationTableEnable + uint32_t coverageModulationTableCount + const float* pCoverageModulationTable + + + VkStructureType sType + const void* pNext + uint32_t viewFormatCount + const VkFormat* pViewFormats + + + + VkStructureType sType + const void* pNext + VkValidationCacheCreateFlagsEXT flags + size_t initialDataSize + const void* pInitialData + + + VkStructureType sType + const void* pNext + VkValidationCacheEXT validationCache + + + VkStructureType sType + void* pNext + uint32_t maxPerSetDescriptors + VkDeviceSize maxMemoryAllocationSize + + + + VkStructureType sType + void* pNext + VkBool32 maintenance4 + + + + VkStructureType sType + void* pNext + VkDeviceSize maxBufferSize + + + + VkStructureType sType + void* pNext + VkBool32 supported + + + + VkStructureType sType + void* pNext + VkBool32 shaderDrawParameters + + + + VkStructureType sType + void* pNext + VkBool32 shaderFloat1616-bit floats (halfs) in shaders + VkBool32 shaderInt88-bit integers in shaders + + + + + VkStructureType sType + void* pNext + VkShaderFloatControlsIndependence denormBehaviorIndependence + VkShaderFloatControlsIndependence roundingModeIndependence + VkBool32 shaderSignedZeroInfNanPreserveFloat16An implementation can preserve signed zero, nan, inf + VkBool32 shaderSignedZeroInfNanPreserveFloat32An implementation can preserve signed zero, nan, inf + VkBool32 shaderSignedZeroInfNanPreserveFloat64An implementation can preserve signed zero, nan, inf + VkBool32 shaderDenormPreserveFloat16An implementation can preserve denormals + VkBool32 shaderDenormPreserveFloat32An implementation can preserve denormals + VkBool32 shaderDenormPreserveFloat64An implementation can preserve denormals + VkBool32 shaderDenormFlushToZeroFloat16An implementation can flush to zero denormals + VkBool32 shaderDenormFlushToZeroFloat32An implementation can flush to zero denormals + VkBool32 shaderDenormFlushToZeroFloat64An implementation can flush to zero denormals + VkBool32 shaderRoundingModeRTEFloat16An implementation can support RTE + VkBool32 shaderRoundingModeRTEFloat32An implementation can support RTE + VkBool32 shaderRoundingModeRTEFloat64An implementation can support RTE + VkBool32 shaderRoundingModeRTZFloat16An implementation can support RTZ + VkBool32 shaderRoundingModeRTZFloat32An implementation can support RTZ + VkBool32 shaderRoundingModeRTZFloat64An implementation can support RTZ + + + + VkStructureType sType + void* pNext + VkBool32 hostQueryReset + + + + uint64_t consumer + uint64_t producer + + + VkStructureType sType + const void* pNext + const void* handle + int stride + int format + int usage + VkNativeBufferUsage2ANDROID usage2 + + + VkStructureType sType + const void* pNext + VkSwapchainImageUsageFlagsANDROID usage + + + VkStructureType sType + const void* pNext + VkBool32 sharedImage + + + uint32_t numUsedVgprs + uint32_t numUsedSgprs + uint32_t ldsSizePerLocalWorkGroup + size_t ldsUsageSizeInBytes + size_t scratchMemUsageInBytes + + + VkShaderStageFlags shaderStageMask + VkShaderResourceUsageAMD resourceUsage + uint32_t numPhysicalVgprs + uint32_t numPhysicalSgprs + uint32_t numAvailableVgprs + uint32_t numAvailableSgprs + uint32_t computeWorkGroupSize[3] + + + VkStructureType sType + const void* pNext + VkQueueGlobalPriorityKHR globalPriority + + + + VkStructureType sType + void* pNext + VkBool32 globalPriorityQuery + + + + VkStructureType sType + void* pNext + uint32_t priorityCount + VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR] + + + + VkStructureType sType + const void* pNext + VkObjectType objectType + uint64_t objectHandle + const char* pObjectName + + + VkStructureType sType + const void* pNext + VkObjectType objectType + uint64_t objectHandle + uint64_t tagName + size_t tagSize + const void* pTag + + + VkStructureType sType + const void* pNext + const char* pLabelName + float color[4] + + + VkStructureType sType + const void* pNext + VkDebugUtilsMessengerCreateFlagsEXT flags + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity + VkDebugUtilsMessageTypeFlagsEXT messageType + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback + void* pUserData + + + VkStructureType sType + const void* pNext + VkDebugUtilsMessengerCallbackDataFlagsEXT flags + const char* pMessageIdName + int32_t messageIdNumber + const char* pMessage + uint32_t queueLabelCount + const VkDebugUtilsLabelEXT* pQueueLabels + uint32_t cmdBufLabelCount + const VkDebugUtilsLabelEXT* pCmdBufLabels + uint32_t objectCount + const VkDebugUtilsObjectNameInfoEXT* pObjects + + + VkStructureType sType + void* pNext + VkBool32 deviceMemoryReport + + + VkStructureType sType + const void* pNext + VkDeviceMemoryReportFlagsEXT flags + PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback + void* pUserData + + + VkStructureType sType + void* pNext + VkDeviceMemoryReportFlagsEXT flags + VkDeviceMemoryReportEventTypeEXT type + uint64_t memoryObjectId + VkDeviceSize size + VkObjectType objectType + uint64_t objectHandle + uint32_t heapIndex + + + VkStructureType sType + const void* pNext + VkExternalMemoryHandleTypeFlagBits handleType + void* pHostPointer + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + + + VkStructureType sType + void* pNext + VkDeviceSize minImportedHostPointerAlignment + + + VkStructureType sType + void* pNext + float primitiveOverestimationSizeThe size in pixels the primitive is enlarged at each edge during conservative rasterization + float maxExtraPrimitiveOverestimationSizeThe maximum additional overestimation the client can specify in the pipeline state + float extraPrimitiveOverestimationSizeGranularityThe granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize + VkBool32 primitiveUnderestimationtrue if the implementation supports conservative rasterization underestimation mode + VkBool32 conservativePointAndLineRasterizationtrue if conservative rasterization also applies to points and lines + VkBool32 degenerateTrianglesRasterizedtrue if degenerate triangles (those with zero area after snap) are rasterized + VkBool32 degenerateLinesRasterizedtrue if degenerate lines (those with zero length after snap) are rasterized + VkBool32 fullyCoveredFragmentShaderInputVariabletrue if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable + VkBool32 conservativeRasterizationPostDepthCoveragetrue if the implementation supports both conservative rasterization and post depth coverage sample coverage mask + + + VkStructureType sType + const void* pNext + VkTimeDomainEXT timeDomain + + + VkStructureType sType + void* pNext + uint32_t shaderEngineCountnumber of shader engines + uint32_t shaderArraysPerEngineCountnumber of shader arrays + uint32_t computeUnitsPerShaderArraynumber of physical CUs per shader array + uint32_t simdPerComputeUnitnumber of SIMDs per compute unit + uint32_t wavefrontsPerSimdnumber of wavefront slots in each SIMD + uint32_t wavefrontSizemaximum number of threads per wavefront + uint32_t sgprsPerSimdnumber of physical SGPRs per SIMD + uint32_t minSgprAllocationminimum number of SGPRs that can be allocated by a wave + uint32_t maxSgprAllocationnumber of available SGPRs + uint32_t sgprAllocationGranularitySGPRs are allocated in groups of this size + uint32_t vgprsPerSimdnumber of physical VGPRs per SIMD + uint32_t minVgprAllocationminimum number of VGPRs that can be allocated by a wave + uint32_t maxVgprAllocationnumber of available VGPRs + uint32_t vgprAllocationGranularityVGPRs are allocated in groups of this size + + + VkStructureType sType + void* pNextPointer to next structure + VkShaderCorePropertiesFlagsAMD shaderCoreFeaturesfeatures supported by the shader core + uint32_t activeComputeUnitCountnumber of active compute units across all shader engines/arrays + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationConservativeStateCreateFlagsEXT flagsReserved + VkConservativeRasterizationModeEXT conservativeRasterizationModeConservative rasterization mode + float extraPrimitiveOverestimationSizeExtra overestimation to add to the primitive + + + VkStructureType sType + void* pNext + VkBool32 shaderInputAttachmentArrayDynamicIndexing + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing + VkBool32 shaderUniformBufferArrayNonUniformIndexing + VkBool32 shaderSampledImageArrayNonUniformIndexing + VkBool32 shaderStorageBufferArrayNonUniformIndexing + VkBool32 shaderStorageImageArrayNonUniformIndexing + VkBool32 shaderInputAttachmentArrayNonUniformIndexing + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing + VkBool32 descriptorBindingUniformBufferUpdateAfterBind + VkBool32 descriptorBindingSampledImageUpdateAfterBind + VkBool32 descriptorBindingStorageImageUpdateAfterBind + VkBool32 descriptorBindingStorageBufferUpdateAfterBind + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind + VkBool32 descriptorBindingUpdateUnusedWhilePending + VkBool32 descriptorBindingPartiallyBound + VkBool32 descriptorBindingVariableDescriptorCount + VkBool32 runtimeDescriptorArray + + + + VkStructureType sType + void* pNext + uint32_t maxUpdateAfterBindDescriptorsInAllPools + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative + VkBool32 shaderSampledImageArrayNonUniformIndexingNative + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative + VkBool32 shaderStorageImageArrayNonUniformIndexingNative + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative + VkBool32 robustBufferAccessUpdateAfterBind + VkBool32 quadDivergentImplicitLod + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments + uint32_t maxPerStageUpdateAfterBindResources + uint32_t maxDescriptorSetUpdateAfterBindSamplers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindSampledImages + uint32_t maxDescriptorSetUpdateAfterBindStorageImages + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments + + + + VkStructureType sType + const void* pNext + uint32_t bindingCount + const VkDescriptorBindingFlags* pBindingFlags + + + + VkStructureType sType + const void* pNext + uint32_t descriptorSetCount + const uint32_t* pDescriptorCounts + + + + VkStructureType sType + void* pNext + uint32_t maxVariableDescriptorCount + + + + VkStructureType sType + const void* pNext + VkAttachmentDescriptionFlags flags + VkFormat format + VkSampleCountFlagBits samples + VkAttachmentLoadOp loadOpLoad operation for color or depth data + VkAttachmentStoreOp storeOpStore operation for color or depth data + VkAttachmentLoadOp stencilLoadOpLoad operation for stencil data + VkAttachmentStoreOp stencilStoreOpStore operation for stencil data + VkImageLayout initialLayout + VkImageLayout finalLayout + + + + VkStructureType sType + const void* pNext + uint32_t attachment + VkImageLayout layout + VkImageAspectFlags aspectMask + + + + VkStructureType sType + const void* pNext + VkSubpassDescriptionFlags flags + VkPipelineBindPoint pipelineBindPoint + uint32_t viewMask + uint32_t inputAttachmentCount + const VkAttachmentReference2* pInputAttachments + uint32_t colorAttachmentCount + const VkAttachmentReference2* pColorAttachments + const VkAttachmentReference2* pResolveAttachments + const VkAttachmentReference2* pDepthStencilAttachment + uint32_t preserveAttachmentCount + const uint32_t* pPreserveAttachments + + + + VkStructureType sType + const void* pNext + uint32_t srcSubpass + uint32_t dstSubpass + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkAccessFlags srcAccessMask + VkAccessFlags dstAccessMask + VkDependencyFlags dependencyFlags + int32_t viewOffset + + + + VkStructureType sType + const void* pNext + VkRenderPassCreateFlags flags + uint32_t attachmentCount + const VkAttachmentDescription2* pAttachments + uint32_t subpassCount + const VkSubpassDescription2* pSubpasses + uint32_t dependencyCount + const VkSubpassDependency2* pDependencies + uint32_t correlatedViewMaskCount + const uint32_t* pCorrelatedViewMasks + + + + VkStructureType sType + const void* pNext + VkSubpassContents contents + + + + VkStructureType sType + const void* pNext + + + + VkStructureType sType + void* pNext + VkBool32 timelineSemaphore + + + + VkStructureType sType + void* pNext + uint64_t maxTimelineSemaphoreValueDifference + + + + VkStructureType sType + const void* pNext + VkSemaphoreType semaphoreType + uint64_t initialValue + + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreValueCount + const uint64_t* pWaitSemaphoreValues + uint32_t signalSemaphoreValueCount + const uint64_t* pSignalSemaphoreValues + + + + VkStructureType sType + const void* pNext + VkSemaphoreWaitFlags flags + uint32_t semaphoreCount + const VkSemaphore* pSemaphores + const uint64_t* pValues + + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + uint64_t value + + + + uint32_t binding + uint32_t divisor + + + VkStructureType sType + const void* pNext + uint32_t vertexBindingDivisorCount + const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors + + + VkStructureType sType + void* pNext + uint32_t maxVertexAttribDivisormax value of vertex attribute divisor + + + VkStructureType sType + void* pNext + uint32_t pciDomain + uint32_t pciBus + uint32_t pciDevice + uint32_t pciFunction + + + VkStructureType sType + const void* pNext + struct AHardwareBuffer* buffer + + + VkStructureType sType + void* pNext + uint64_t androidHardwareBufferUsage + + + VkStructureType sType + void* pNext + VkDeviceSize allocationSize + uint32_t memoryTypeBits + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + + + VkStructureType sType + void* pNext + VkFormat format + uint64_t externalFormat + VkFormatFeatureFlags formatFeatures + VkComponentMapping samplerYcbcrConversionComponents + VkSamplerYcbcrModelConversion suggestedYcbcrModel + VkSamplerYcbcrRange suggestedYcbcrRange + VkChromaLocation suggestedXChromaOffset + VkChromaLocation suggestedYChromaOffset + + + VkStructureType sType + const void* pNext + VkBool32 conditionalRenderingEnableWhether this secondary command buffer may be executed during an active conditional rendering + + + VkStructureType sType + void* pNext + uint64_t externalFormat + + + VkStructureType sType + void* pNext + VkBool32 storageBuffer8BitAccess8-bit integer variables supported in StorageBuffer + VkBool32 uniformAndStorageBuffer8BitAccess8-bit integer variables supported in StorageBuffer and Uniform + VkBool32 storagePushConstant88-bit integer variables supported in PushConstant + + + + VkStructureType sType + void* pNext + VkBool32 conditionalRendering + VkBool32 inheritedConditionalRendering + + + VkStructureType sType + void* pNext + VkBool32 vulkanMemoryModel + VkBool32 vulkanMemoryModelDeviceScope + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains + + + + VkStructureType sType + void* pNext + VkBool32 shaderBufferInt64Atomics + VkBool32 shaderSharedInt64Atomics + + + + VkStructureType sType + void* pNext + VkBool32 shaderBufferFloat32Atomics + VkBool32 shaderBufferFloat32AtomicAdd + VkBool32 shaderBufferFloat64Atomics + VkBool32 shaderBufferFloat64AtomicAdd + VkBool32 shaderSharedFloat32Atomics + VkBool32 shaderSharedFloat32AtomicAdd + VkBool32 shaderSharedFloat64Atomics + VkBool32 shaderSharedFloat64AtomicAdd + VkBool32 shaderImageFloat32Atomics + VkBool32 shaderImageFloat32AtomicAdd + VkBool32 sparseImageFloat32Atomics + VkBool32 sparseImageFloat32AtomicAdd + + + VkStructureType sType + void* pNext + VkBool32 shaderBufferFloat16Atomics + VkBool32 shaderBufferFloat16AtomicAdd + VkBool32 shaderBufferFloat16AtomicMinMax + VkBool32 shaderBufferFloat32AtomicMinMax + VkBool32 shaderBufferFloat64AtomicMinMax + VkBool32 shaderSharedFloat16Atomics + VkBool32 shaderSharedFloat16AtomicAdd + VkBool32 shaderSharedFloat16AtomicMinMax + VkBool32 shaderSharedFloat32AtomicMinMax + VkBool32 shaderSharedFloat64AtomicMinMax + VkBool32 shaderImageFloat32AtomicMinMax + VkBool32 sparseImageFloat32AtomicMinMax + + + VkStructureType sType + void* pNext + VkBool32 vertexAttributeInstanceRateDivisor + VkBool32 vertexAttributeInstanceRateZeroDivisor + + + VkStructureType sType + void* pNext + VkPipelineStageFlags checkpointExecutionStageMask + + + VkStructureType sType + void* pNext + VkPipelineStageFlagBits stage + void* pCheckpointMarker + + + VkStructureType sType + void* pNext + VkResolveModeFlags supportedDepthResolveModessupported depth resolve modes + VkResolveModeFlags supportedStencilResolveModessupported stencil resolve modes + VkBool32 independentResolveNonedepth and stencil resolve modes can be set independently if one of them is none + VkBool32 independentResolvedepth and stencil resolve modes can be set independently + + + + VkStructureType sType + const void* pNext + VkResolveModeFlagBits depthResolveModedepth resolve mode + VkResolveModeFlagBits stencilResolveModestencil resolve mode + const VkAttachmentReference2* pDepthStencilResolveAttachmentdepth/stencil resolve attachment + + + + VkStructureType sType + const void* pNext + VkFormat decodeMode + + + VkStructureType sType + void* pNext + VkBool32 decodeModeSharedExponent + + + VkStructureType sType + void* pNext + VkBool32 transformFeedback + VkBool32 geometryStreams + + + VkStructureType sType + void* pNext + uint32_t maxTransformFeedbackStreams + uint32_t maxTransformFeedbackBuffers + VkDeviceSize maxTransformFeedbackBufferSize + uint32_t maxTransformFeedbackStreamDataSize + uint32_t maxTransformFeedbackBufferDataSize + uint32_t maxTransformFeedbackBufferDataStride + VkBool32 transformFeedbackQueries + VkBool32 transformFeedbackStreamsLinesTriangles + VkBool32 transformFeedbackRasterizationStreamSelect + VkBool32 transformFeedbackDraw + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationStateStreamCreateFlagsEXT flags + uint32_t rasterizationStream + + + VkStructureType sType + void* pNext + VkBool32 representativeFragmentTest + + + VkStructureType sType + const void* pNext + VkBool32 representativeFragmentTestEnable + + + VkStructureType sType + void* pNext + VkBool32 exclusiveScissor + + + VkStructureType sType + const void* pNext + uint32_t exclusiveScissorCount + const VkRect2D* pExclusiveScissors + + + VkStructureType sType + void* pNext + VkBool32 cornerSampledImage + + + VkStructureType sType + void* pNext + VkBool32 computeDerivativeGroupQuads + VkBool32 computeDerivativeGroupLinear + + + + VkStructureType sType + void* pNext + VkBool32 imageFootprint + + + VkStructureType sType + void* pNext + VkBool32 dedicatedAllocationImageAliasing + + + VkStructureType sType + void* pNext + VkBool32 indirectCopy + + + VkStructureType sType + void* pNext + VkQueueFlags supportedQueuesBitfield of which queues are supported for indirect copy + + + VkStructureType sType + void* pNext + VkBool32 memoryDecompression + + + VkStructureType sType + void* pNext + VkMemoryDecompressionMethodFlagsNV decompressionMethods + uint64_t maxDecompressionIndirectCount + + + uint32_t shadingRatePaletteEntryCount + const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries + + + VkStructureType sType + const void* pNext + VkBool32 shadingRateImageEnable + uint32_t viewportCount + const VkShadingRatePaletteNV* pShadingRatePalettes + + + VkStructureType sType + void* pNext + VkBool32 shadingRateImage + VkBool32 shadingRateCoarseSampleOrder + + + VkStructureType sType + void* pNext + VkExtent2D shadingRateTexelSize + uint32_t shadingRatePaletteSize + uint32_t shadingRateMaxCoarseSamples + + + VkStructureType sType + void* pNext + VkBool32 invocationMask + + + uint32_t pixelX + uint32_t pixelY + uint32_t sample + + + VkShadingRatePaletteEntryNV shadingRate + uint32_t sampleCount + uint32_t sampleLocationCount + const VkCoarseSampleLocationNV* pSampleLocations + + + VkStructureType sType + const void* pNext + VkCoarseSampleOrderTypeNV sampleOrderType + uint32_t customSampleOrderCount + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders + + + VkStructureType sType + void* pNext + VkBool32 taskShader + VkBool32 meshShader + + + VkStructureType sType + void* pNext + uint32_t maxDrawMeshTasksCount + uint32_t maxTaskWorkGroupInvocations + uint32_t maxTaskWorkGroupSize[3] + uint32_t maxTaskTotalMemorySize + uint32_t maxTaskOutputCount + uint32_t maxMeshWorkGroupInvocations + uint32_t maxMeshWorkGroupSize[3] + uint32_t maxMeshTotalMemorySize + uint32_t maxMeshOutputVertices + uint32_t maxMeshOutputPrimitives + uint32_t maxMeshMultiviewViewCount + uint32_t meshOutputPerVertexGranularity + uint32_t meshOutputPerPrimitiveGranularity + + + uint32_t taskCount + uint32_t firstTask + + + VkStructureType sType + void* pNext + VkBool32 taskShader + VkBool32 meshShader + VkBool32 multiviewMeshShader + VkBool32 primitiveFragmentShadingRateMeshShader + VkBool32 meshShaderQueries + + + VkStructureType sType + void* pNext + uint32_t maxTaskWorkGroupTotalCount + uint32_t maxTaskWorkGroupCount[3] + uint32_t maxTaskWorkGroupInvocations + uint32_t maxTaskWorkGroupSize[3] + uint32_t maxTaskPayloadSize + uint32_t maxTaskSharedMemorySize + uint32_t maxTaskPayloadAndSharedMemorySize + uint32_t maxMeshWorkGroupTotalCount + uint32_t maxMeshWorkGroupCount[3] + uint32_t maxMeshWorkGroupInvocations + uint32_t maxMeshWorkGroupSize[3] + uint32_t maxMeshSharedMemorySize + uint32_t maxMeshPayloadAndSharedMemorySize + uint32_t maxMeshOutputMemorySize + uint32_t maxMeshPayloadAndOutputMemorySize + uint32_t maxMeshOutputComponents + uint32_t maxMeshOutputVertices + uint32_t maxMeshOutputPrimitives + uint32_t maxMeshOutputLayers + uint32_t maxMeshMultiviewViewCount + uint32_t meshOutputPerVertexGranularity + uint32_t meshOutputPerPrimitiveGranularity + uint32_t maxPreferredTaskWorkGroupInvocations + uint32_t maxPreferredMeshWorkGroupInvocations + VkBool32 prefersLocalInvocationVertexOutput + VkBool32 prefersLocalInvocationPrimitiveOutput + VkBool32 prefersCompactVertexOutput + VkBool32 prefersCompactPrimitiveOutput + + + uint32_t groupCountX + uint32_t groupCountY + uint32_t groupCountZ + + + VkStructureType sType + const void* pNext + VkRayTracingShaderGroupTypeKHR type + uint32_t generalShader + uint32_t closestHitShader + uint32_t anyHitShader + uint32_t intersectionShader + + + VkStructureType sType + const void* pNext + VkRayTracingShaderGroupTypeKHR type + uint32_t generalShader + uint32_t closestHitShader + uint32_t anyHitShader + uint32_t intersectionShader + const void* pShaderGroupCaptureReplayHandle + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + uint32_t stageCount + const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage + uint32_t groupCount + const VkRayTracingShaderGroupCreateInfoNV* pGroups + uint32_t maxRecursionDepth + VkPipelineLayout layoutInterface layout of the pipeline + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flagsPipeline creation flags + uint32_t stageCount + const VkPipelineShaderStageCreateInfo* pStagesOne entry for each active shader stage + uint32_t groupCount + const VkRayTracingShaderGroupCreateInfoKHR* pGroups + uint32_t maxPipelineRayRecursionDepth + const VkPipelineLibraryCreateInfoKHR* pLibraryInfo + const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface + const VkPipelineDynamicStateCreateInfo* pDynamicState + VkPipelineLayout layoutInterface layout of the pipeline + VkPipeline basePipelineHandleIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of + int32_t basePipelineIndexIf VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of + + + VkStructureType sType + const void* pNext + VkBuffer vertexData + VkDeviceSize vertexOffset + uint32_t vertexCount + VkDeviceSize vertexStride + VkFormat vertexFormat + VkBuffer indexData + VkDeviceSize indexOffset + uint32_t indexCount + VkIndexType indexType + VkBuffer transformDataOptional reference to array of floats representing a 3x4 row major affine transformation matrix. + VkDeviceSize transformOffset + + + VkStructureType sType + const void* pNext + VkBuffer aabbData + uint32_t numAABBs + uint32_t strideStride in bytes between AABBs + VkDeviceSize offsetOffset in bytes of the first AABB in aabbData + + + VkGeometryTrianglesNV triangles + VkGeometryAABBNV aabbs + + + VkStructureType sType + const void* pNext + VkGeometryTypeKHR geometryType + VkGeometryDataNV geometry + VkGeometryFlagsKHR flags + + + VkStructureType sType + const void* pNext + VkAccelerationStructureTypeNV type + VkBuildAccelerationStructureFlagsNV flags + uint32_t instanceCount + uint32_t geometryCount + const VkGeometryNV* pGeometries + + + VkStructureType sType + const void* pNext + VkDeviceSize compactedSize + VkAccelerationStructureInfoNV info + + + VkStructureType sType + const void* pNext + VkAccelerationStructureNV accelerationStructure + VkDeviceMemory memory + VkDeviceSize memoryOffset + uint32_t deviceIndexCount + const uint32_t* pDeviceIndices + + + VkStructureType sType + const void* pNext + uint32_t accelerationStructureCount + const VkAccelerationStructureKHR* pAccelerationStructures + + + VkStructureType sType + const void* pNext + uint32_t accelerationStructureCount + const VkAccelerationStructureNV* pAccelerationStructures + + + VkStructureType sType + const void* pNext + VkAccelerationStructureMemoryRequirementsTypeNV type + VkAccelerationStructureNV accelerationStructure + + + VkStructureType sType + void* pNext + VkBool32 accelerationStructure + VkBool32 accelerationStructureCaptureReplay + VkBool32 accelerationStructureIndirectBuild + VkBool32 accelerationStructureHostCommands + VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind + + + VkStructureType sType + void* pNext + VkBool32 rayTracingPipeline + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed + VkBool32 rayTracingPipelineTraceRaysIndirect + VkBool32 rayTraversalPrimitiveCulling + + + VkStructureType sType + void* pNext + VkBool32 rayQuery + + + VkStructureType sType + void* pNext + uint64_t maxGeometryCount + uint64_t maxInstanceCount + uint64_t maxPrimitiveCount + uint32_t maxPerStageDescriptorAccelerationStructures + uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures + uint32_t maxDescriptorSetAccelerationStructures + uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures + uint32_t minAccelerationStructureScratchOffsetAlignment + + + VkStructureType sType + void* pNext + uint32_t shaderGroupHandleSize + uint32_t maxRayRecursionDepth + uint32_t maxShaderGroupStride + uint32_t shaderGroupBaseAlignment + uint32_t shaderGroupHandleCaptureReplaySize + uint32_t maxRayDispatchInvocationCount + uint32_t shaderGroupHandleAlignment + uint32_t maxRayHitAttributeSize + + + VkStructureType sType + void* pNext + uint32_t shaderGroupHandleSize + uint32_t maxRecursionDepth + uint32_t maxShaderGroupStride + uint32_t shaderGroupBaseAlignment + uint64_t maxGeometryCount + uint64_t maxInstanceCount + uint64_t maxTriangleCount + uint32_t maxDescriptorSetAccelerationStructures + + + VkDeviceAddress deviceAddress + VkDeviceSize stride + VkDeviceSize size + + + uint32_t width + uint32_t height + uint32_t depth + + + VkDeviceAddress raygenShaderRecordAddress + VkDeviceSize raygenShaderRecordSize + VkDeviceAddress missShaderBindingTableAddress + VkDeviceSize missShaderBindingTableSize + VkDeviceSize missShaderBindingTableStride + VkDeviceAddress hitShaderBindingTableAddress + VkDeviceSize hitShaderBindingTableSize + VkDeviceSize hitShaderBindingTableStride + VkDeviceAddress callableShaderBindingTableAddress + VkDeviceSize callableShaderBindingTableSize + VkDeviceSize callableShaderBindingTableStride + uint32_t width + uint32_t height + uint32_t depth + + + VkStructureType sType + void* pNext + VkBool32 rayTracingMaintenance1 + VkBool32 rayTracingPipelineTraceRaysIndirect2 + + + VkStructureType sType + void* pNext + uint32_t drmFormatModifierCount + VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties + + + uint64_t drmFormatModifier + uint32_t drmFormatModifierPlaneCount + VkFormatFeatureFlags drmFormatModifierTilingFeatures + + + VkStructureType sType + const void* pNext + uint64_t drmFormatModifier + VkSharingMode sharingMode + uint32_t queueFamilyIndexCount + const uint32_t* pQueueFamilyIndices + + + VkStructureType sType + const void* pNext + uint32_t drmFormatModifierCount + const uint64_t* pDrmFormatModifiers + + + VkStructureType sType + const void* pNext + uint64_t drmFormatModifier + uint32_t drmFormatModifierPlaneCount + const VkSubresourceLayout* pPlaneLayouts + + + VkStructureType sType + void* pNext + uint64_t drmFormatModifier + + + VkStructureType sType + const void* pNext + VkImageUsageFlags stencilUsage + + + + VkStructureType sType + const void* pNext + VkMemoryOverallocationBehaviorAMD overallocationBehavior + + + VkStructureType sType + void* pNext + VkBool32 fragmentDensityMap + VkBool32 fragmentDensityMapDynamic + VkBool32 fragmentDensityMapNonSubsampledImages + + + VkStructureType sType + void* pNext + VkBool32 fragmentDensityMapDeferred + + + VkStructureType sType + void* pNext + VkBool32 fragmentDensityMapOffset + + + VkStructureType sType + void* pNext + VkExtent2D minFragmentDensityTexelSize + VkExtent2D maxFragmentDensityTexelSize + VkBool32 fragmentDensityInvocations + + + VkStructureType sType + void* pNext + VkBool32 subsampledLoads + VkBool32 subsampledCoarseReconstructionEarlyAccess + uint32_t maxSubsampledArrayLayers + uint32_t maxDescriptorSetSubsampledSamplers + + + VkStructureType sType + void* pNext + VkExtent2D fragmentDensityOffsetGranularity + + + VkStructureType sType + const void* pNext + VkAttachmentReference fragmentDensityMapAttachment + + + VkStructureType sType + const void* pNext + uint32_t fragmentDensityOffsetCount + const VkOffset2D* pFragmentDensityOffsets + + + VkStructureType sType + void* pNext + VkBool32 scalarBlockLayout + + + + VkStructureType sType + const void* pNext + VkBool32 supportsProtectedRepresents if surface can be protected + + + VkStructureType sType + void* pNext + VkBool32 uniformBufferStandardLayout + + + + VkStructureType sType + void* pNext + VkBool32 depthClipEnable + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationDepthClipStateCreateFlagsEXT flagsReserved + VkBool32 depthClipEnable + + + VkStructureType sType + void* pNext + VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS] + VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS] + + + VkStructureType sType + void* pNext + VkBool32 memoryPriority + + + VkStructureType sType + const void* pNext + float priority + + + VkStructureType sType + void* pNext + VkBool32 pageableDeviceLocalMemory + + + VkStructureType sType + void* pNext + VkBool32 bufferDeviceAddress + VkBool32 bufferDeviceAddressCaptureReplay + VkBool32 bufferDeviceAddressMultiDevice + + + + VkStructureType sType + void* pNext + VkBool32 bufferDeviceAddress + VkBool32 bufferDeviceAddressCaptureReplay + VkBool32 bufferDeviceAddressMultiDevice + + + + VkStructureType sType + const void* pNext + VkBuffer buffer + + + + + VkStructureType sType + const void* pNext + uint64_t opaqueCaptureAddress + + + + VkStructureType sType + const void* pNext + VkDeviceAddress deviceAddress + + + VkStructureType sType + void* pNext + VkImageViewType imageViewType + + + VkStructureType sType + void* pNext + VkBool32 filterCubicThe combinations of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT + VkBool32 filterCubicMinmaxThe combination of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT and ReductionMode of Min or Max + + + VkStructureType sType + void* pNext + VkBool32 imagelessFramebuffer + + + + VkStructureType sType + const void* pNext + uint32_t attachmentImageInfoCount + const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos + + + + VkStructureType sType + const void* pNext + VkImageCreateFlags flagsImage creation flags + VkImageUsageFlags usageImage usage flags + uint32_t width + uint32_t height + uint32_t layerCount + uint32_t viewFormatCount + const VkFormat* pViewFormats + + + + VkStructureType sType + const void* pNext + uint32_t attachmentCount + const VkImageView* pAttachments + + + + VkStructureType sType + void* pNext + VkBool32 textureCompressionASTC_HDR + + + + VkStructureType sType + void* pNext + VkBool32 cooperativeMatrix + VkBool32 cooperativeMatrixRobustBufferAccess + + + VkStructureType sType + void* pNext + VkShaderStageFlags cooperativeMatrixSupportedStages + + + VkStructureType sType + void* pNext + uint32_t MSize + uint32_t NSize + uint32_t KSize + VkComponentTypeNV AType + VkComponentTypeNV BType + VkComponentTypeNV CType + VkComponentTypeNV DType + VkScopeNV scope + + + VkStructureType sType + void* pNext + VkBool32 ycbcrImageArrays + + + VkStructureType sType + const void* pNext + VkImageView imageView + VkDescriptorType descriptorType + VkSampler sampler + + + VkStructureType sType + void* pNext + VkDeviceAddress deviceAddress + VkDeviceSize size + + + VkStructureType sType + const void* pNext + GgpFrameToken frameToken + + + VkPipelineCreationFeedbackFlags flags + uint64_t duration + + + + VkStructureType sType + const void* pNext + VkPipelineCreationFeedback* pPipelineCreationFeedbackOutput pipeline creation feedback. + uint32_t pipelineStageCreationFeedbackCount + VkPipelineCreationFeedback* pPipelineStageCreationFeedbacksOne entry for each shader stage specified in the parent Vk*PipelineCreateInfo struct + + + + VkStructureType sType + void* pNext + VkFullScreenExclusiveEXT fullScreenExclusive + + + VkStructureType sType + const void* pNext + HMONITOR hmonitor + + + VkStructureType sType + void* pNext + VkBool32 fullScreenExclusiveSupported + + + VkStructureType sType + void* pNext + VkBool32 presentBarrier + + + VkStructureType sType + void* pNext + VkBool32 presentBarrierSupported + + + VkStructureType sType + void* pNext + VkBool32 presentBarrierEnable + + + VkStructureType sType + void* pNext + VkBool32 performanceCounterQueryPoolsperformance counters supported in query pools + VkBool32 performanceCounterMultipleQueryPoolsperformance counters from multiple query pools can be accessed in the same primary command buffer + + + VkStructureType sType + void* pNext + VkBool32 allowCommandBufferQueryCopiesFlag to specify whether performance queries are allowed to be used in vkCmdCopyQueryPoolResults + + + VkStructureType sType + void* pNext + VkPerformanceCounterUnitKHR unit + VkPerformanceCounterScopeKHR scope + VkPerformanceCounterStorageKHR storage + uint8_t uuid[VK_UUID_SIZE] + + + VkStructureType sType + void* pNext + VkPerformanceCounterDescriptionFlagsKHR flags + char name[VK_MAX_DESCRIPTION_SIZE] + char category[VK_MAX_DESCRIPTION_SIZE] + char description[VK_MAX_DESCRIPTION_SIZE] + + + VkStructureType sType + const void* pNext + uint32_t queueFamilyIndex + uint32_t counterIndexCount + const uint32_t* pCounterIndices + + + int32_t int32 + int64_t int64 + uint32_t uint32 + uint64_t uint64 + float float32 + double float64 + + + VkStructureType sType + const void* pNext + VkAcquireProfilingLockFlagsKHR flagsAcquire profiling lock flags + uint64_t timeout + + + VkStructureType sType + const void* pNext + uint32_t counterPassIndexIndex for which counter pass to submit + + + VkStructureType sType + const void* pNext + uint32_t maxPerformanceQueriesPerPoolMaximum number of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR queries in a query pool + + + VkStructureType sType + const void* pNext + VkHeadlessSurfaceCreateFlagsEXT flags + + + VkStructureType sType + void* pNext + VkBool32 coverageReductionMode + + + VkStructureType sType + const void* pNext + VkPipelineCoverageReductionStateCreateFlagsNV flags + VkCoverageReductionModeNV coverageReductionMode + + + VkStructureType sType + void* pNext + VkCoverageReductionModeNV coverageReductionMode + VkSampleCountFlagBits rasterizationSamples + VkSampleCountFlags depthStencilSamples + VkSampleCountFlags colorSamples + + + VkStructureType sType + void* pNext + VkBool32 shaderIntegerFunctions2 + + + uint32_t value32 + uint64_t value64 + float valueFloat + VkBool32 valueBool + const char* valueString + + + VkPerformanceValueTypeINTEL type + VkPerformanceValueDataINTEL data + + + VkStructureType sType + const void* pNext + void* pUserData + + + VkStructureType sType + const void* pNext + VkQueryPoolSamplingModeINTEL performanceCountersSampling + + + + VkStructureType sType + const void* pNext + uint64_t marker + + + VkStructureType sType + const void* pNext + uint32_t marker + + + VkStructureType sType + const void* pNext + VkPerformanceOverrideTypeINTEL type + VkBool32 enable + uint64_t parameter + + + VkStructureType sType + const void* pNext + VkPerformanceConfigurationTypeINTEL type + + + VkStructureType sType + void* pNext + VkBool32 shaderSubgroupClock + VkBool32 shaderDeviceClock + + + VkStructureType sType + void* pNext + VkBool32 indexTypeUint8 + + + VkStructureType sType + void* pNext + uint32_t shaderSMCount + uint32_t shaderWarpsPerSM + + + VkStructureType sType + void* pNext + VkBool32 shaderSMBuiltins + + + VkStructureType sType + void* pNextPointer to next structure + VkBool32 fragmentShaderSampleInterlock + VkBool32 fragmentShaderPixelInterlock + VkBool32 fragmentShaderShadingRateInterlock + + + VkStructureType sType + void* pNext + VkBool32 separateDepthStencilLayouts + + + + VkStructureType sType + void* pNext + VkImageLayout stencilLayout + + + VkStructureType sType + void* pNext + VkBool32 primitiveTopologyListRestart + VkBool32 primitiveTopologyPatchListRestart + + + + VkStructureType sType + void* pNext + VkImageLayout stencilInitialLayout + VkImageLayout stencilFinalLayout + + + + VkStructureType sType + void* pNext + VkBool32 pipelineExecutableInfo + + + VkStructureType sType + const void* pNext + VkPipeline pipeline + + + + VkStructureType sType + void* pNext + VkShaderStageFlags stages + char name[VK_MAX_DESCRIPTION_SIZE] + char description[VK_MAX_DESCRIPTION_SIZE] + uint32_t subgroupSize + + + VkStructureType sType + const void* pNext + VkPipeline pipeline + uint32_t executableIndex + + + VkBool32 b32 + int64_t i64 + uint64_t u64 + double f64 + + + VkStructureType sType + void* pNext + char name[VK_MAX_DESCRIPTION_SIZE] + char description[VK_MAX_DESCRIPTION_SIZE] + VkPipelineExecutableStatisticFormatKHR format + VkPipelineExecutableStatisticValueKHR value + + + VkStructureType sType + void* pNext + char name[VK_MAX_DESCRIPTION_SIZE] + char description[VK_MAX_DESCRIPTION_SIZE] + VkBool32 isText + size_t dataSize + void* pData + + + VkStructureType sType + void* pNext + VkBool32 shaderDemoteToHelperInvocation + + + + VkStructureType sType + void* pNext + VkBool32 texelBufferAlignment + + + VkStructureType sType + void* pNext + VkDeviceSize storageTexelBufferOffsetAlignmentBytes + VkBool32 storageTexelBufferOffsetSingleTexelAlignment + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment + + + + VkStructureType sType + void* pNext + VkBool32 subgroupSizeControl + VkBool32 computeFullSubgroups + + + + VkStructureType sType + void* pNext + uint32_t minSubgroupSizeThe minimum subgroup size supported by this device + uint32_t maxSubgroupSizeThe maximum subgroup size supported by this device + uint32_t maxComputeWorkgroupSubgroupsThe maximum number of subgroups supported in a workgroup + VkShaderStageFlags requiredSubgroupSizeStagesThe shader stages that support specifying a subgroup size + + + + VkStructureType sType + void* pNext + uint32_t requiredSubgroupSize + + + + + VkStructureType sType + void* pNext + VkRenderPass renderPass + uint32_t subpass + + + VkStructureType sType + void* pNext + uint32_t maxSubpassShadingWorkgroupSizeAspectRatio + + + VkStructureType sType + void* pNext + uint32_t maxWorkGroupCount[3] + uint32_t maxWorkGroupSize[3] + uint32_t maxOutputClusterCount + VkDeviceSize indirectBufferOffsetAlignment + + + VkStructureType sType + const void* pNext + uint64_t opaqueCaptureAddress + + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + + + + VkStructureType sType + void* pNext + VkBool32 rectangularLines + VkBool32 bresenhamLines + VkBool32 smoothLines + VkBool32 stippledRectangularLines + VkBool32 stippledBresenhamLines + VkBool32 stippledSmoothLines + + + VkStructureType sType + void* pNext + uint32_t lineSubPixelPrecisionBits + + + VkStructureType sType + const void* pNext + VkLineRasterizationModeEXT lineRasterizationMode + VkBool32 stippledLineEnable + uint32_t lineStippleFactor + uint16_t lineStipplePattern + + + VkStructureType sType + void* pNext + VkBool32 pipelineCreationCacheControl + + + + VkStructureType sType + void* pNext + VkBool32 storageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock + VkBool32 uniformAndStorageBuffer16BitAccess16-bit integer/floating-point variables supported in BufferBlock and Block + VkBool32 storagePushConstant1616-bit integer/floating-point variables supported in PushConstant + VkBool32 storageInputOutput1616-bit integer/floating-point variables supported in shader inputs and outputs + VkBool32 multiviewMultiple views in a renderpass + VkBool32 multiviewGeometryShaderMultiple views in a renderpass w/ geometry shader + VkBool32 multiviewTessellationShaderMultiple views in a renderpass w/ tessellation shader + VkBool32 variablePointersStorageBuffer + VkBool32 variablePointers + VkBool32 protectedMemory + VkBool32 samplerYcbcrConversionSampler color conversion supported + VkBool32 shaderDrawParameters + + + VkStructureType sType + void* pNext + uint8_t deviceUUID[VK_UUID_SIZE] + uint8_t driverUUID[VK_UUID_SIZE] + uint8_t deviceLUID[VK_LUID_SIZE] + uint32_t deviceNodeMask + VkBool32 deviceLUIDValid + uint32_t subgroupSizeThe size of a subgroup for this queue. + VkShaderStageFlags subgroupSupportedStagesBitfield of what shader stages support subgroup operations + VkSubgroupFeatureFlags subgroupSupportedOperationsBitfield of what subgroup operations are supported. + VkBool32 subgroupQuadOperationsInAllStagesFlag to specify whether quad operations are available in all stages. + VkPointClippingBehavior pointClippingBehavior + uint32_t maxMultiviewViewCountmax number of views in a subpass + uint32_t maxMultiviewInstanceIndexmax instance index for a draw in a multiview subpass + VkBool32 protectedNoFault + uint32_t maxPerSetDescriptors + VkDeviceSize maxMemoryAllocationSize + + + VkStructureType sType + void* pNext + VkBool32 samplerMirrorClampToEdge + VkBool32 drawIndirectCount + VkBool32 storageBuffer8BitAccess8-bit integer variables supported in StorageBuffer + VkBool32 uniformAndStorageBuffer8BitAccess8-bit integer variables supported in StorageBuffer and Uniform + VkBool32 storagePushConstant88-bit integer variables supported in PushConstant + VkBool32 shaderBufferInt64Atomics + VkBool32 shaderSharedInt64Atomics + VkBool32 shaderFloat1616-bit floats (halfs) in shaders + VkBool32 shaderInt88-bit integers in shaders + VkBool32 descriptorIndexing + VkBool32 shaderInputAttachmentArrayDynamicIndexing + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing + VkBool32 shaderUniformBufferArrayNonUniformIndexing + VkBool32 shaderSampledImageArrayNonUniformIndexing + VkBool32 shaderStorageBufferArrayNonUniformIndexing + VkBool32 shaderStorageImageArrayNonUniformIndexing + VkBool32 shaderInputAttachmentArrayNonUniformIndexing + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing + VkBool32 descriptorBindingUniformBufferUpdateAfterBind + VkBool32 descriptorBindingSampledImageUpdateAfterBind + VkBool32 descriptorBindingStorageImageUpdateAfterBind + VkBool32 descriptorBindingStorageBufferUpdateAfterBind + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind + VkBool32 descriptorBindingUpdateUnusedWhilePending + VkBool32 descriptorBindingPartiallyBound + VkBool32 descriptorBindingVariableDescriptorCount + VkBool32 runtimeDescriptorArray + VkBool32 samplerFilterMinmax + VkBool32 scalarBlockLayout + VkBool32 imagelessFramebuffer + VkBool32 uniformBufferStandardLayout + VkBool32 shaderSubgroupExtendedTypes + VkBool32 separateDepthStencilLayouts + VkBool32 hostQueryReset + VkBool32 timelineSemaphore + VkBool32 bufferDeviceAddress + VkBool32 bufferDeviceAddressCaptureReplay + VkBool32 bufferDeviceAddressMultiDevice + VkBool32 vulkanMemoryModel + VkBool32 vulkanMemoryModelDeviceScope + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains + VkBool32 shaderOutputViewportIndex + VkBool32 shaderOutputLayer + VkBool32 subgroupBroadcastDynamicId + + + VkStructureType sType + void* pNext + VkDriverId driverID + char driverName[VK_MAX_DRIVER_NAME_SIZE] + char driverInfo[VK_MAX_DRIVER_INFO_SIZE] + VkConformanceVersion conformanceVersion + VkShaderFloatControlsIndependence denormBehaviorIndependence + VkShaderFloatControlsIndependence roundingModeIndependence + VkBool32 shaderSignedZeroInfNanPreserveFloat16An implementation can preserve signed zero, nan, inf + VkBool32 shaderSignedZeroInfNanPreserveFloat32An implementation can preserve signed zero, nan, inf + VkBool32 shaderSignedZeroInfNanPreserveFloat64An implementation can preserve signed zero, nan, inf + VkBool32 shaderDenormPreserveFloat16An implementation can preserve denormals + VkBool32 shaderDenormPreserveFloat32An implementation can preserve denormals + VkBool32 shaderDenormPreserveFloat64An implementation can preserve denormals + VkBool32 shaderDenormFlushToZeroFloat16An implementation can flush to zero denormals + VkBool32 shaderDenormFlushToZeroFloat32An implementation can flush to zero denormals + VkBool32 shaderDenormFlushToZeroFloat64An implementation can flush to zero denormals + VkBool32 shaderRoundingModeRTEFloat16An implementation can support RTE + VkBool32 shaderRoundingModeRTEFloat32An implementation can support RTE + VkBool32 shaderRoundingModeRTEFloat64An implementation can support RTE + VkBool32 shaderRoundingModeRTZFloat16An implementation can support RTZ + VkBool32 shaderRoundingModeRTZFloat32An implementation can support RTZ + VkBool32 shaderRoundingModeRTZFloat64An implementation can support RTZ + uint32_t maxUpdateAfterBindDescriptorsInAllPools + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative + VkBool32 shaderSampledImageArrayNonUniformIndexingNative + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative + VkBool32 shaderStorageImageArrayNonUniformIndexingNative + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative + VkBool32 robustBufferAccessUpdateAfterBind + VkBool32 quadDivergentImplicitLod + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments + uint32_t maxPerStageUpdateAfterBindResources + uint32_t maxDescriptorSetUpdateAfterBindSamplers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic + uint32_t maxDescriptorSetUpdateAfterBindSampledImages + uint32_t maxDescriptorSetUpdateAfterBindStorageImages + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments + VkResolveModeFlags supportedDepthResolveModessupported depth resolve modes + VkResolveModeFlags supportedStencilResolveModessupported stencil resolve modes + VkBool32 independentResolveNonedepth and stencil resolve modes can be set independently if one of them is none + VkBool32 independentResolvedepth and stencil resolve modes can be set independently + VkBool32 filterMinmaxSingleComponentFormats + VkBool32 filterMinmaxImageComponentMapping + uint64_t maxTimelineSemaphoreValueDifference + VkSampleCountFlags framebufferIntegerColorSampleCounts + + + VkStructureType sType + void* pNext + VkBool32 robustImageAccess + VkBool32 inlineUniformBlock + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind + VkBool32 pipelineCreationCacheControl + VkBool32 privateData + VkBool32 shaderDemoteToHelperInvocation + VkBool32 shaderTerminateInvocation + VkBool32 subgroupSizeControl + VkBool32 computeFullSubgroups + VkBool32 synchronization2 + VkBool32 textureCompressionASTC_HDR + VkBool32 shaderZeroInitializeWorkgroupMemory + VkBool32 dynamicRendering + VkBool32 shaderIntegerDotProduct + VkBool32 maintenance4 + + + VkStructureType sType + void* pNext + uint32_t minSubgroupSizeThe minimum subgroup size supported by this device + uint32_t maxSubgroupSizeThe maximum subgroup size supported by this device + uint32_t maxComputeWorkgroupSubgroupsThe maximum number of subgroups supported in a workgroup + VkShaderStageFlags requiredSubgroupSizeStagesThe shader stages that support specifying a subgroup size + uint32_t maxInlineUniformBlockSize + uint32_t maxPerStageDescriptorInlineUniformBlocks + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks + uint32_t maxDescriptorSetInlineUniformBlocks + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks + uint32_t maxInlineUniformTotalSize + VkBool32 integerDotProduct8BitUnsignedAccelerated + VkBool32 integerDotProduct8BitSignedAccelerated + VkBool32 integerDotProduct8BitMixedSignednessAccelerated + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated + VkBool32 integerDotProduct16BitUnsignedAccelerated + VkBool32 integerDotProduct16BitSignedAccelerated + VkBool32 integerDotProduct16BitMixedSignednessAccelerated + VkBool32 integerDotProduct32BitUnsignedAccelerated + VkBool32 integerDotProduct32BitSignedAccelerated + VkBool32 integerDotProduct32BitMixedSignednessAccelerated + VkBool32 integerDotProduct64BitUnsignedAccelerated + VkBool32 integerDotProduct64BitSignedAccelerated + VkBool32 integerDotProduct64BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated + VkDeviceSize storageTexelBufferOffsetAlignmentBytes + VkBool32 storageTexelBufferOffsetSingleTexelAlignment + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment + VkDeviceSize maxBufferSize + + + VkStructureType sType + const void* pNext + VkPipelineCompilerControlFlagsAMD compilerControlFlags + + + VkStructureType sType + void* pNext + VkBool32 deviceCoherentMemory + + + VkStructureType sType + void* pNext + VkFaultLevel faultLevel + VkFaultType faultType + + + VkStructureType sType + void* pNext + uint32_t faultCount + VkFaultData*pFaults + PFN_vkFaultCallbackFunction pfnFaultCallback + + + VkStructureType sType + void* pNext + char name[VK_MAX_EXTENSION_NAME_SIZE] + char version[VK_MAX_EXTENSION_NAME_SIZE] + VkToolPurposeFlags purposes + char description[VK_MAX_DESCRIPTION_SIZE] + char layer[VK_MAX_EXTENSION_NAME_SIZE] + + + + VkStructureType sType + const void* pNext + VkClearColorValue customBorderColor + VkFormat format + + + VkStructureType sType + void* pNext + uint32_t maxCustomBorderColorSamplers + + + VkStructureType sType + void* pNext + VkBool32 customBorderColors + VkBool32 customBorderColorWithoutFormat + + + VkStructureType sType + const void* pNext + VkComponentMapping components + VkBool32 srgb + + + VkStructureType sType + void* pNext + VkBool32 borderColorSwizzle + VkBool32 borderColorSwizzleFromImage + + + VkDeviceAddress deviceAddress + void* hostAddress + + + VkDeviceAddress deviceAddress + const void* hostAddress + + + VkStructureType sType + const void* pNext + VkFormat vertexFormat + VkDeviceOrHostAddressConstKHR vertexData + VkDeviceSize vertexStride + uint32_t maxVertex + VkIndexType indexType + VkDeviceOrHostAddressConstKHR indexData + VkDeviceOrHostAddressConstKHR transformData + + + VkStructureType sType + const void* pNext + VkDeviceOrHostAddressConstKHR data + VkDeviceSize stride + + + VkStructureType sType + const void* pNext + VkBool32 arrayOfPointers + VkDeviceOrHostAddressConstKHR data + + + VkAccelerationStructureGeometryTrianglesDataKHR triangles + VkAccelerationStructureGeometryAabbsDataKHR aabbs + VkAccelerationStructureGeometryInstancesDataKHR instances + + + VkStructureType sType + const void* pNext + VkGeometryTypeKHR geometryType + VkAccelerationStructureGeometryDataKHR geometry + VkGeometryFlagsKHR flags + + + VkStructureType sType + const void* pNext + VkAccelerationStructureTypeKHR type + VkBuildAccelerationStructureFlagsKHR flags + VkBuildAccelerationStructureModeKHR mode + VkAccelerationStructureKHR srcAccelerationStructure + VkAccelerationStructureKHR dstAccelerationStructure + uint32_t geometryCount + const VkAccelerationStructureGeometryKHR* pGeometries + const VkAccelerationStructureGeometryKHR* const* ppGeometries + VkDeviceOrHostAddressKHR scratchData + + + uint32_t primitiveCount + uint32_t primitiveOffset + uint32_t firstVertex + uint32_t transformOffset + + + VkStructureType sType + const void* pNext + VkAccelerationStructureCreateFlagsKHR createFlags + VkBuffer buffer + VkDeviceSize offsetSpecified in bytes + VkDeviceSize size + VkAccelerationStructureTypeKHR type + VkDeviceAddress deviceAddress + + + float minX + float minY + float minZ + float maxX + float maxY + float maxZ + + + + float matrix[3][4] + + + + The bitfields in this structure are non-normative since bitfield ordering is implementation-defined in C. The specification defines the normative layout. + VkTransformMatrixKHR transform + uint32_t instanceCustomIndex:24 + uint32_t mask:8 + uint32_t instanceShaderBindingTableRecordOffset:24 + VkGeometryInstanceFlagsKHR flags:8 + uint64_t accelerationStructureReference + + + + VkStructureType sType + const void* pNext + VkAccelerationStructureKHR accelerationStructure + + + VkStructureType sType + const void* pNext + const uint8_t* pVersionData + + + VkStructureType sType + const void* pNext + VkAccelerationStructureKHR src + VkAccelerationStructureKHR dst + VkCopyAccelerationStructureModeKHR mode + + + VkStructureType sType + const void* pNext + VkAccelerationStructureKHR src + VkDeviceOrHostAddressKHR dst + VkCopyAccelerationStructureModeKHR mode + + + VkStructureType sType + const void* pNext + VkDeviceOrHostAddressConstKHR src + VkAccelerationStructureKHR dst + VkCopyAccelerationStructureModeKHR mode + + + VkStructureType sType + const void* pNext + uint32_t maxPipelineRayPayloadSize + uint32_t maxPipelineRayHitAttributeSize + + + VkStructureType sType + const void* pNext + uint32_t libraryCount + const VkPipeline* pLibraries + + + VkObjectType objectType + uint64_t objectHandle + VkRefreshObjectFlagsKHR flags + + + VkStructureType sType + const void* pNext + uint32_t objectCount + const VkRefreshObjectKHR* pObjects + + + VkStructureType sType + void* pNext + VkBool32 extendedDynamicState + + + VkStructureType sType + void* pNext + VkBool32 extendedDynamicState2 + VkBool32 extendedDynamicState2LogicOp + VkBool32 extendedDynamicState2PatchControlPoints + + + VkStructureType sType + void* pNext + VkBool32 extendedDynamicState3TessellationDomainOrigin + VkBool32 extendedDynamicState3DepthClampEnable + VkBool32 extendedDynamicState3PolygonMode + VkBool32 extendedDynamicState3RasterizationSamples + VkBool32 extendedDynamicState3SampleMask + VkBool32 extendedDynamicState3AlphaToCoverageEnable + VkBool32 extendedDynamicState3AlphaToOneEnable + VkBool32 extendedDynamicState3LogicOpEnable + VkBool32 extendedDynamicState3ColorBlendEnable + VkBool32 extendedDynamicState3ColorBlendEquation + VkBool32 extendedDynamicState3ColorWriteMask + VkBool32 extendedDynamicState3RasterizationStream + VkBool32 extendedDynamicState3ConservativeRasterizationMode + VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize + VkBool32 extendedDynamicState3DepthClipEnable + VkBool32 extendedDynamicState3SampleLocationsEnable + VkBool32 extendedDynamicState3ColorBlendAdvanced + VkBool32 extendedDynamicState3ProvokingVertexMode + VkBool32 extendedDynamicState3LineRasterizationMode + VkBool32 extendedDynamicState3LineStippleEnable + VkBool32 extendedDynamicState3DepthClipNegativeOneToOne + VkBool32 extendedDynamicState3ViewportWScalingEnable + VkBool32 extendedDynamicState3ViewportSwizzle + VkBool32 extendedDynamicState3CoverageToColorEnable + VkBool32 extendedDynamicState3CoverageToColorLocation + VkBool32 extendedDynamicState3CoverageModulationMode + VkBool32 extendedDynamicState3CoverageModulationTableEnable + VkBool32 extendedDynamicState3CoverageModulationTable + VkBool32 extendedDynamicState3CoverageReductionMode + VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable + VkBool32 extendedDynamicState3ShadingRateImageEnable + + + VkStructureType sType + void* pNext + VkBool32 dynamicPrimitiveTopologyUnrestricted + + + VkBlendFactor srcColorBlendFactor + VkBlendFactor dstColorBlendFactor + VkBlendOp colorBlendOp + VkBlendFactor srcAlphaBlendFactor + VkBlendFactor dstAlphaBlendFactor + VkBlendOp alphaBlendOp + + + VkBlendOp advancedBlendOp + VkBool32 srcPremultiplied + VkBool32 dstPremultiplied + VkBlendOverlapEXT blendOverlap + VkBool32 clampResults + + + VkStructureType sType + void* pNextPointer to next structure + VkSurfaceTransformFlagBitsKHR transform + + + VkStructureType sType + const void* pNext + VkSurfaceTransformFlagBitsKHR transform + + + VkStructureType sType + void* pNextPointer to next structure + VkSurfaceTransformFlagBitsKHR transform + VkRect2D renderArea + + + VkStructureType sType + void* pNext + VkBool32 diagnosticsConfig + + + VkStructureType sType + const void* pNext + VkDeviceDiagnosticsConfigFlagsNV flags + + + VkStructureType sType + const void* pNext + uint8_t pipelineIdentifier[VK_UUID_SIZE] + VkPipelineMatchControl matchControl + VkDeviceSize poolEntrySize + + + VkStructureType sType + void* pNext + VkBool32 shaderZeroInitializeWorkgroupMemory + + + + VkStructureType sType + void* pNext + VkBool32 shaderSubgroupUniformControlFlow + + + VkStructureType sType + void* pNext + VkBool32 robustBufferAccess2 + VkBool32 robustImageAccess2 + VkBool32 nullDescriptor + + + VkStructureType sType + void* pNext + VkDeviceSize robustStorageBufferAccessSizeAlignment + VkDeviceSize robustUniformBufferAccessSizeAlignment + + + VkStructureType sType + void* pNext + VkBool32 robustImageAccess + + + + VkStructureType sType + void* pNext + VkBool32 workgroupMemoryExplicitLayout + VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout + VkBool32 workgroupMemoryExplicitLayout8BitAccess + VkBool32 workgroupMemoryExplicitLayout16BitAccess + + + VkStructureType sType + void* pNext + VkBool32 constantAlphaColorBlendFactors + VkBool32 events + VkBool32 imageViewFormatReinterpretation + VkBool32 imageViewFormatSwizzle + VkBool32 imageView2DOn3DImage + VkBool32 multisampleArrayImage + VkBool32 mutableComparisonSamplers + VkBool32 pointPolygons + VkBool32 samplerMipLodBias + VkBool32 separateStencilMaskRef + VkBool32 shaderSampleRateInterpolationFunctions + VkBool32 tessellationIsolines + VkBool32 tessellationPointMode + VkBool32 triangleFans + VkBool32 vertexAttributeAccessBeyondStride + + + VkStructureType sType + void* pNext + uint32_t minVertexInputBindingStrideAlignment + + + VkStructureType sType + void* pNext + VkBool32 formatA4R4G4B4 + VkBool32 formatA4B4G4R4 + + + VkStructureType sType + void* pNext + VkBool32 subpassShading + + + VkStructureType sType + void*pNext + VkBool32 clustercullingShader + VkBool32 multiviewClusterCullingShader + + + VkStructureType sType + const void* pNext + VkDeviceSize srcOffsetSpecified in bytes + VkDeviceSize dstOffsetSpecified in bytes + VkDeviceSize sizeSpecified in bytes + + + + VkStructureType sType + const void* pNext + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsetSpecified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D extentSpecified in pixels for both compressed and uncompressed images + + + + VkStructureType sType + const void* pNext + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsets[2]Specified in pixels for both compressed and uncompressed images + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsets[2]Specified in pixels for both compressed and uncompressed images + + + + VkStructureType sType + const void* pNext + VkDeviceSize bufferOffsetSpecified in bytes + uint32_t bufferRowLengthSpecified in texels + uint32_t bufferImageHeight + VkImageSubresourceLayers imageSubresource + VkOffset3D imageOffsetSpecified in pixels for both compressed and uncompressed images + VkExtent3D imageExtentSpecified in pixels for both compressed and uncompressed images + + + + VkStructureType sType + const void* pNext + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffset + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffset + VkExtent3D extent + + + + VkStructureType sType + const void* pNext + VkBuffer srcBuffer + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferCopy2* pRegions + + + + VkStructureType sType + const void* pNext + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageCopy2* pRegions + + + + VkStructureType sType + const void* pNext + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageBlit2* pRegions + VkFilter filter + + + + VkStructureType sType + const void* pNext + VkBuffer srcBuffer + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkBufferImageCopy2* pRegions + + + + VkStructureType sType + const void* pNext + VkImage srcImage + VkImageLayout srcImageLayout + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferImageCopy2* pRegions + + + + VkStructureType sType + const void* pNext + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageResolve2* pRegions + + + + VkStructureType sType + void* pNext + VkBool32 shaderImageInt64Atomics + VkBool32 sparseImageInt64Atomics + + + VkStructureType sType + const void* pNext + const VkAttachmentReference2* pFragmentShadingRateAttachment + VkExtent2D shadingRateAttachmentTexelSize + + + VkStructureType sType + const void* pNext + VkExtent2D fragmentSize + VkFragmentShadingRateCombinerOpKHR combinerOps[2] + + + VkStructureType sType + void* pNext + VkBool32 pipelineFragmentShadingRate + VkBool32 primitiveFragmentShadingRate + VkBool32 attachmentFragmentShadingRate + + + VkStructureType sType + void* pNext + VkExtent2D minFragmentShadingRateAttachmentTexelSize + VkExtent2D maxFragmentShadingRateAttachmentTexelSize + uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio + VkBool32 primitiveFragmentShadingRateWithMultipleViewports + VkBool32 layeredShadingRateAttachments + VkBool32 fragmentShadingRateNonTrivialCombinerOps + VkExtent2D maxFragmentSize + uint32_t maxFragmentSizeAspectRatio + uint32_t maxFragmentShadingRateCoverageSamples + VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples + VkBool32 fragmentShadingRateWithShaderDepthStencilWrites + VkBool32 fragmentShadingRateWithSampleMask + VkBool32 fragmentShadingRateWithShaderSampleMask + VkBool32 fragmentShadingRateWithConservativeRasterization + VkBool32 fragmentShadingRateWithFragmentShaderInterlock + VkBool32 fragmentShadingRateWithCustomSampleLocations + VkBool32 fragmentShadingRateStrictMultiplyCombiner + + + VkStructureType sType + void* pNext + VkSampleCountFlags sampleCounts + VkExtent2D fragmentSize + + + VkStructureType sType + void* pNext + VkBool32 shaderTerminateInvocation + + + + VkStructureType sType + void* pNext + VkBool32 fragmentShadingRateEnums + VkBool32 supersampleFragmentShadingRates + VkBool32 noInvocationFragmentShadingRates + + + VkStructureType sType + void* pNext + VkSampleCountFlagBits maxFragmentShadingRateInvocationCount + + + VkStructureType sType + const void* pNext + VkFragmentShadingRateTypeNV shadingRateType + VkFragmentShadingRateNV shadingRate + VkFragmentShadingRateCombinerOpKHR combinerOps[2] + + + VkStructureType sType + const void* pNext + VkDeviceSize accelerationStructureSize + VkDeviceSize updateScratchSize + VkDeviceSize buildScratchSize + + + VkStructureType sType + void* pNext + VkBool32 image2DViewOf3D + VkBool32 sampler2DViewOf3D + + + VkStructureType sType + void* pNext + VkBool32 imageSlicedViewOf3D + + + VkStructureType sType + void* pNext + VkBool32 mutableDescriptorType + + + + uint32_t descriptorTypeCount + const VkDescriptorType* pDescriptorTypes + + + + VkStructureType sType + const void* pNext + uint32_t mutableDescriptorTypeListCount + const VkMutableDescriptorTypeListEXT* pMutableDescriptorTypeLists + + + + VkStructureType sType + void* pNext + VkBool32 depthClipControl + + + VkStructureType sType + const void* pNext + VkBool32 negativeOneToOne + + + VkStructureType sType + void* pNext + VkBool32 vertexInputDynamicState + + + VkStructureType sType + void* pNext + VkBool32 externalMemoryRDMA + + + VkStructureType sType + void* pNext + uint32_t binding + uint32_t stride + VkVertexInputRate inputRate + uint32_t divisor + + + VkStructureType sType + void* pNext + uint32_t locationlocation of the shader vertex attrib + uint32_t bindingVertex buffer binding id + VkFormat formatformat of source data + uint32_t offsetOffset of first element in bytes from base of vertex + + + VkStructureType sType + void* pNext + VkBool32 colorWriteEnable + + + VkStructureType sType + const void* pNext + uint32_t attachmentCount# of pAttachments + const VkBool32* pColorWriteEnables + + + VkStructureType sType + const void* pNext + VkPipelineStageFlags2 srcStageMask + VkAccessFlags2 srcAccessMask + VkPipelineStageFlags2 dstStageMask + VkAccessFlags2 dstAccessMask + + + + VkStructureType sType + const void* pNext + VkPipelineStageFlags2 srcStageMask + VkAccessFlags2 srcAccessMask + VkPipelineStageFlags2 dstStageMask + VkAccessFlags2 dstAccessMask + VkImageLayout oldLayout + VkImageLayout newLayout + uint32_t srcQueueFamilyIndex + uint32_t dstQueueFamilyIndex + VkImage image + VkImageSubresourceRange subresourceRange + + + + VkStructureType sType + const void* pNext + VkPipelineStageFlags2 srcStageMask + VkAccessFlags2 srcAccessMask + VkPipelineStageFlags2 dstStageMask + VkAccessFlags2 dstAccessMask + uint32_t srcQueueFamilyIndex + uint32_t dstQueueFamilyIndex + VkBuffer buffer + VkDeviceSize offset + VkDeviceSize size + + + + VkStructureType sType + const void* pNext + VkDependencyFlags dependencyFlags + uint32_t memoryBarrierCount + const VkMemoryBarrier2* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier2* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier2* pImageMemoryBarriers + + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + uint64_t value + VkPipelineStageFlags2 stageMask + uint32_t deviceIndex + + + + VkStructureType sType + const void* pNext + VkCommandBuffer commandBuffer + uint32_t deviceMask + + + + VkStructureType sType + const void* pNext + VkSubmitFlags flags + uint32_t waitSemaphoreInfoCount + const VkSemaphoreSubmitInfo* pWaitSemaphoreInfos + uint32_t commandBufferInfoCount + const VkCommandBufferSubmitInfo* pCommandBufferInfos + uint32_t signalSemaphoreInfoCount + const VkSemaphoreSubmitInfo* pSignalSemaphoreInfos + + + + VkStructureType sType + void* pNext + VkPipelineStageFlags2 checkpointExecutionStageMask + + + VkStructureType sType + void* pNext + VkPipelineStageFlags2 stage + void* pCheckpointMarker + + + VkStructureType sType + void* pNext + VkBool32 synchronization2 + + + + VkStructureType sType + void* pNext + VkBool32 deviceNoDynamicHostAllocations + VkBool32 deviceDestroyFreesMemory + VkBool32 commandPoolMultipleCommandBuffersRecording + VkBool32 commandPoolResetCommandBuffer + VkBool32 commandBufferSimultaneousUse + VkBool32 secondaryCommandBufferNullOrImagelessFramebuffer + VkBool32 recycleDescriptorSetMemory + VkBool32 recyclePipelineMemory + uint32_t maxRenderPassSubpasses + uint32_t maxRenderPassDependencies + uint32_t maxSubpassInputAttachments + uint32_t maxSubpassPreserveAttachments + uint32_t maxFramebufferAttachments + uint32_t maxDescriptorSetLayoutBindings + uint32_t maxQueryFaultCount + uint32_t maxCallbackFaultCount + uint32_t maxCommandPoolCommandBuffers + VkDeviceSize maxCommandBufferSize + + + VkStructureType sType + const void* pNext + VkDeviceSize poolEntrySize + uint32_t poolEntryCount + + + VkStructureType sType + const void* pNext + uint32_t pipelineCacheCreateInfoCount + const VkPipelineCacheCreateInfo* pPipelineCacheCreateInfos + uint32_t pipelinePoolSizeCount + const VkPipelinePoolSize* pPipelinePoolSizes + uint32_t semaphoreRequestCount + uint32_t commandBufferRequestCount + uint32_t fenceRequestCount + uint32_t deviceMemoryRequestCount + uint32_t bufferRequestCount + uint32_t imageRequestCount + uint32_t eventRequestCount + uint32_t queryPoolRequestCount + uint32_t bufferViewRequestCount + uint32_t imageViewRequestCount + uint32_t layeredImageViewRequestCount + uint32_t pipelineCacheRequestCount + uint32_t pipelineLayoutRequestCount + uint32_t renderPassRequestCount + uint32_t graphicsPipelineRequestCount + uint32_t computePipelineRequestCount + uint32_t descriptorSetLayoutRequestCount + uint32_t samplerRequestCount + uint32_t descriptorPoolRequestCount + uint32_t descriptorSetRequestCount + uint32_t framebufferRequestCount + uint32_t commandPoolRequestCount + uint32_t samplerYcbcrConversionRequestCount + uint32_t surfaceRequestCount + uint32_t swapchainRequestCount + uint32_t displayModeRequestCount + uint32_t subpassDescriptionRequestCount + uint32_t attachmentDescriptionRequestCount + uint32_t descriptorSetLayoutBindingRequestCount + uint32_t descriptorSetLayoutBindingLimit + uint32_t maxImageViewMipLevels + uint32_t maxImageViewArrayLayers + uint32_t maxLayeredImageViewMipLevels + uint32_t maxOcclusionQueriesPerPool + uint32_t maxPipelineStatisticsQueriesPerPool + uint32_t maxTimestampQueriesPerPool + uint32_t maxImmutableSamplersPerDescriptorSetLayout + + + VkStructureType sType + const void* pNext + VkDeviceSize commandPoolReservedSize + uint32_t commandPoolMaxCommandBuffers + + + VkStructureType sType + void* pNext + VkDeviceSize commandPoolAllocated + VkDeviceSize commandPoolReservedSize + VkDeviceSize commandBufferAllocated + + + VkStructureType sType + void* pNext + VkBool32 shaderAtomicInstructions + + + VkStructureType sType + void* pNext + VkBool32 primitivesGeneratedQuery + VkBool32 primitivesGeneratedQueryWithRasterizerDiscard + VkBool32 primitivesGeneratedQueryWithNonZeroStreams + + + VkStructureType sType + void* pNext + VkBool32 legacyDithering + + + VkStructureType sType + void* pNext + VkBool32 multisampledRenderToSingleSampled + + + VkStructureType sType + void* pNext + VkBool32 optimal + + + VkStructureType sType + const void* pNext + VkBool32 multisampledRenderToSingleSampledEnable + VkSampleCountFlagBits rasterizationSamples + + + VkStructureType sType + void* pNext + VkBool32 pipelineProtectedAccess + + + VkStructureType sType + void* pNext + VkVideoCodecOperationFlagsKHR videoCodecOperations + + + VkStructureType sType + void* pNext + VkBool32 queryResultStatusSupport + + + VkStructureType sType + const void* pNext + uint32_t profileCount + const VkVideoProfileInfoKHR* pProfiles + + + VkStructureType sType + const void* pNext + VkImageUsageFlags imageUsage + + + VkStructureType sType + void* pNext + VkFormat format + VkComponentMapping componentMapping + VkImageCreateFlags imageCreateFlags + VkImageType imageType + VkImageTiling imageTiling + VkImageUsageFlags imageUsageFlags + + + VkStructureType sType + const void* pNext + VkVideoCodecOperationFlagBitsKHR videoCodecOperation + VkVideoChromaSubsamplingFlagsKHR chromaSubsampling + VkVideoComponentBitDepthFlagsKHR lumaBitDepth + VkVideoComponentBitDepthFlagsKHR chromaBitDepth + + + VkStructureType sType + void* pNext + VkVideoCapabilityFlagsKHR flags + VkDeviceSize minBitstreamBufferOffsetAlignment + VkDeviceSize minBitstreamBufferSizeAlignment + VkExtent2D pictureAccessGranularity + VkExtent2D minCodedExtent + VkExtent2D maxCodedExtent + uint32_t maxDpbSlots + uint32_t maxActiveReferencePictures + VkExtensionProperties stdHeaderVersion + + + VkStructureType sType + void* pNext + uint32_t memoryBindIndex + VkMemoryRequirements memoryRequirements + + + VkStructureType sType + const void* pNext + uint32_t memoryBindIndex + VkDeviceMemory memory + VkDeviceSize memoryOffset + VkDeviceSize memorySize + + + VkStructureType sType + const void* pNext + VkOffset2D codedOffsetThe offset to be used for the picture resource, currently only used in field mode + VkExtent2D codedExtentThe extent to be used for the picture resource + uint32_t baseArrayLayerThe first array layer to be accessed for the Decode or Encode Operations + VkImageView imageViewBindingThe ImageView binding of the resource + + + VkStructureType sType + const void* pNext + int32_t slotIndexThe reference slot index + const VkVideoPictureResourceInfoKHR* pPictureResourceThe reference picture resource + + + VkStructureType sType + void* pNext + VkVideoDecodeCapabilityFlagsKHR flags + + + VkStructureType sType + const void* pNext + VkVideoDecodeUsageFlagsKHR videoUsageHints + + + VkStructureType sType + const void* pNext + VkVideoDecodeFlagsKHR flags + VkBuffer srcBuffer + VkDeviceSize srcBufferOffset + VkDeviceSize srcBufferRange + VkVideoPictureResourceInfoKHR dstPictureResource + const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot + uint32_t referenceSlotCount + const VkVideoReferenceSlotInfoKHR* pReferenceSlots + + Video Decode Codec Standard specific structures + #include "vk_video/vulkan_video_codec_h264std.h" + + + + + + + + + + + + + + + + + + + #include "vk_video/vulkan_video_codec_h264std_decode.h" + + + + + + VkStructureType sType + const void* pNext + StdVideoH264ProfileIdc stdProfileIdc + VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout + + + VkStructureType sType + void* pNext + StdVideoH264LevelIdc maxLevelIdc + VkOffset2D fieldOffsetGranularity + + + + + VkStructureType sType + const void* pNext + uint32_t stdSPSCount + const StdVideoH264SequenceParameterSet* pStdSPSs + uint32_t stdPPSCount + const StdVideoH264PictureParameterSet* pStdPPSsList of Picture Parameters associated with the spsStd, above + + + VkStructureType sType + const void* pNext + uint32_t maxStdSPSCount + uint32_t maxStdPPSCount + const VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo + + + VkStructureType sType + const void* pNext + const StdVideoDecodeH264PictureInfo* pStdPictureInfo + uint32_t sliceCount + const uint32_t* pSliceOffsets + + + VkStructureType sType + const void* pNext + const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo + + #include "vk_video/vulkan_video_codec_h265std.h" + + + + + + + + + + + + + + + + + + + #include "vk_video/vulkan_video_codec_h265std_decode.h" + + + + + + VkStructureType sType + const void* pNext + StdVideoH265ProfileIdc stdProfileIdc + + + VkStructureType sType + void* pNext + StdVideoH265LevelIdc maxLevelIdc + + + VkStructureType sType + const void* pNext + uint32_t stdVPSCount + const StdVideoH265VideoParameterSet* pStdVPSs + uint32_t stdSPSCount + const StdVideoH265SequenceParameterSet* pStdSPSs + uint32_t stdPPSCount + const StdVideoH265PictureParameterSet* pStdPPSsList of Picture Parameters associated with the spsStd, above + + + VkStructureType sType + const void* pNext + uint32_t maxStdVPSCount + uint32_t maxStdSPSCount + uint32_t maxStdPPSCount + const VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo + + + VkStructureType sType + const void* pNext + StdVideoDecodeH265PictureInfo* pStdPictureInfo + uint32_t sliceSegmentCount + const uint32_t* pSliceSegmentOffsets + + + VkStructureType sType + const void* pNext + const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo + + + VkStructureType sType + const void* pNext + uint32_t queueFamilyIndex + VkVideoSessionCreateFlagsKHR flags + const VkVideoProfileInfoKHR* pVideoProfile + VkFormat pictureFormat + VkExtent2D maxCodedExtent + VkFormat referencePictureFormat + uint32_t maxDpbSlots + uint32_t maxActiveReferencePictures + const VkExtensionProperties* pStdHeaderVersion + + + VkStructureType sType + const void* pNext + VkVideoSessionParametersCreateFlagsKHR flags + VkVideoSessionParametersKHR videoSessionParametersTemplate + VkVideoSessionKHR videoSession + + + VkStructureType sType + const void* pNext + uint32_t updateSequenceCount + + + VkStructureType sType + const void* pNext + VkVideoBeginCodingFlagsKHR flags + VkVideoSessionKHR videoSession + VkVideoSessionParametersKHR videoSessionParameters + uint32_t referenceSlotCount + const VkVideoReferenceSlotInfoKHR* pReferenceSlots + + + VkStructureType sType + const void* pNext + VkVideoEndCodingFlagsKHR flags + + + VkStructureType sType + const void* pNext + VkVideoCodingControlFlagsKHR flags + + + VkStructureType sType + const void* pNext + VkVideoEncodeUsageFlagsKHR videoUsageHints + VkVideoEncodeContentFlagsKHR videoContentHints + VkVideoEncodeTuningModeKHR tuningMode + + + VkStructureType sType + const void* pNext + VkVideoEncodeFlagsKHR flags + uint32_t qualityLevel + VkBuffer dstBuffer + VkDeviceSize dstBufferOffset + VkDeviceSize dstBufferRange + VkVideoPictureResourceInfoKHR srcPictureResource + const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot + uint32_t referenceSlotCount + const VkVideoReferenceSlotInfoKHR* pReferenceSlots + uint32_t precedingExternallyEncodedBytes + + + VkStructureType sType + const void* pNext + VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags + + + VkStructureType sType + const void* pNext + VkVideoEncodeRateControlFlagsKHR flags + VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode + uint32_t layerCount + const VkVideoEncodeRateControlLayerInfoKHR* pLayers + + + VkStructureType sType + const void* pNext + uint64_t averageBitrate + uint64_t maxBitrate + uint32_t frameRateNumerator + uint32_t frameRateDenominator + uint32_t virtualBufferSizeInMs + uint32_t initialVirtualBufferSizeInMs + + + VkStructureType sType + void* pNext + VkVideoEncodeCapabilityFlagsKHR flags + VkVideoEncodeRateControlModeFlagsKHR rateControlModes + uint32_t maxRateControlLayers + uint32_t maxQualityLevels + VkExtent2D inputImageDataFillAlignment + VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags + + + VkStructureType sType + void* pNext + VkVideoEncodeH264CapabilityFlagsEXT flags + uint32_t maxPPictureL0ReferenceCount + uint32_t maxBPictureL0ReferenceCount + uint32_t maxL1ReferenceCount + VkBool32 motionVectorsOverPicBoundariesFlag + uint32_t maxBytesPerPicDenom + uint32_t maxBitsPerMbDenom + uint32_t log2MaxMvLengthHorizontal + uint32_t log2MaxMvLengthVertical + + #include "vk_video/vulkan_video_codec_h264std_encode.h" + + + + + + + + + + + + VkStructureType sType + const void* pNext + uint32_t stdSPSCount + const StdVideoH264SequenceParameterSet* pStdSPSs + uint32_t stdPPSCount + const StdVideoH264PictureParameterSet* pStdPPSsList of Picture Parameters associated with the spsStd, above + + + VkStructureType sType + const void* pNext + uint32_t maxStdSPSCount + uint32_t maxStdPPSCount + const VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo + + + VkStructureType sType + const void* pNext + const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo + + + VkStructureType sType + const void* pNext + const StdVideoEncodeH264ReferenceListsInfo* pStdReferenceFinalLists + uint32_t naluSliceEntryCount + const VkVideoEncodeH264NaluSliceInfoEXT* pNaluSliceEntries + const StdVideoEncodeH264PictureInfo* pStdPictureInfo + + + VkStructureType sType + const void* pNext + StdVideoH264ProfileIdc stdProfileIdc + + + VkStructureType sType + const void* pNext + uint32_t mbCount + const StdVideoEncodeH264ReferenceListsInfo* pStdReferenceFinalLists + const StdVideoEncodeH264SliceHeader* pStdSliceHeader + + + VkStructureType sType + const void* pNext + uint32_t gopFrameCount + uint32_t idrPeriod + uint32_t consecutiveBFrameCount + VkVideoEncodeH264RateControlStructureEXT rateControlStructure + uint32_t temporalLayerCount + + + int32_t qpI + int32_t qpP + int32_t qpB + + + uint32_t frameISize + uint32_t framePSize + uint32_t frameBSize + + + VkStructureType sType + const void* pNext + uint32_t temporalLayerId + VkBool32 useInitialRcQp + VkVideoEncodeH264QpEXT initialRcQp + VkBool32 useMinQp + VkVideoEncodeH264QpEXT minQp + VkBool32 useMaxQp + VkVideoEncodeH264QpEXT maxQp + VkBool32 useMaxFrameSize + VkVideoEncodeH264FrameSizeEXT maxFrameSize + + + VkStructureType sType + void* pNext + VkVideoEncodeH265CapabilityFlagsEXT flags + VkVideoEncodeH265CtbSizeFlagsEXT ctbSizes + VkVideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes + uint32_t maxPPictureL0ReferenceCount + uint32_t maxBPictureL0ReferenceCount + uint32_t maxL1ReferenceCount + uint32_t maxSubLayersCount + uint32_t minLog2MinLumaCodingBlockSizeMinus3 + uint32_t maxLog2MinLumaCodingBlockSizeMinus3 + uint32_t minLog2MinLumaTransformBlockSizeMinus2 + uint32_t maxLog2MinLumaTransformBlockSizeMinus2 + uint32_t minMaxTransformHierarchyDepthInter + uint32_t maxMaxTransformHierarchyDepthInter + uint32_t minMaxTransformHierarchyDepthIntra + uint32_t maxMaxTransformHierarchyDepthIntra + uint32_t maxDiffCuQpDeltaDepth + uint32_t minMaxNumMergeCand + uint32_t maxMaxNumMergeCand + + #include "vk_video/vulkan_video_codec_h265std_encode.h" + + + + + + + + + + VkStructureType sType + const void* pNext + uint32_t stdVPSCount + const StdVideoH265VideoParameterSet* pStdVPSs + uint32_t stdSPSCount + const StdVideoH265SequenceParameterSet* pStdSPSs + uint32_t stdPPSCount + const StdVideoH265PictureParameterSet* pStdPPSsList of Picture Parameters associated with the spsStd, above + + + VkStructureType sType + const void* pNext + uint32_t maxStdVPSCount + uint32_t maxStdSPSCount + uint32_t maxStdPPSCount + const VkVideoEncodeH265SessionParametersAddInfoEXT* pParametersAddInfo + + + VkStructureType sType + const void* pNext + const StdVideoEncodeH265ReferenceListsInfo* pStdReferenceFinalLists + uint32_t naluSliceSegmentEntryCount + const VkVideoEncodeH265NaluSliceSegmentInfoEXT* pNaluSliceSegmentEntries + const StdVideoEncodeH265PictureInfo* pStdPictureInfo + + + VkStructureType sType + const void* pNext + uint32_t ctbCount + const StdVideoEncodeH265ReferenceListsInfo* pStdReferenceFinalLists + const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader + + + VkStructureType sType + const void* pNext + uint32_t gopFrameCount + uint32_t idrPeriod + uint32_t consecutiveBFrameCount + VkVideoEncodeH265RateControlStructureEXT rateControlStructure + uint32_t subLayerCount + + + int32_t qpI + int32_t qpP + int32_t qpB + + + uint32_t frameISize + uint32_t framePSize + uint32_t frameBSize + + + VkStructureType sType + const void* pNext + uint32_t temporalId + VkBool32 useInitialRcQp + VkVideoEncodeH265QpEXT initialRcQp + VkBool32 useMinQp + VkVideoEncodeH265QpEXT minQp + VkBool32 useMaxQp + VkVideoEncodeH265QpEXT maxQp + VkBool32 useMaxFrameSize + VkVideoEncodeH265FrameSizeEXT maxFrameSize + + + VkStructureType sType + const void* pNext + StdVideoH265ProfileIdc stdProfileIdc + + + VkStructureType sType + const void* pNext + const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo + + + VkStructureType sType + void* pNext + VkBool32 inheritedViewportScissor2D + + + VkStructureType sType + const void* pNext + VkBool32 viewportScissor2D + uint32_t viewportDepthCount + const VkViewport* pViewportDepths + + + VkStructureType sType + void* pNext + VkBool32 ycbcr2plane444Formats + + + VkStructureType sType + void* pNext + VkBool32 provokingVertexLast + VkBool32 transformFeedbackPreservesProvokingVertex + + + VkStructureType sType + void* pNext + VkBool32 provokingVertexModePerPipeline + VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex + + + VkStructureType sType + const void* pNext + VkProvokingVertexModeEXT provokingVertexMode + + + VkStructureType sType + const void* pNext + size_t dataSize + const void* pData + + + VkStructureType sType + const void* pNext + VkCuModuleNVX module + const char* pName + + + VkStructureType sType + const void* pNext + VkCuFunctionNVX function + uint32_t gridDimX + uint32_t gridDimY + uint32_t gridDimZ + uint32_t blockDimX + uint32_t blockDimY + uint32_t blockDimZ + uint32_t sharedMemBytes + size_t paramCount + const void* const * pParams + size_t extraCount + const void* const * pExtras + + + VkStructureType sType + void* pNext + VkBool32 descriptorBuffer + VkBool32 descriptorBufferCaptureReplay + VkBool32 descriptorBufferImageLayoutIgnored + VkBool32 descriptorBufferPushDescriptors + + + VkStructureType sType + void* pNext + VkBool32 combinedImageSamplerDescriptorSingleArray + VkBool32 bufferlessPushDescriptors + VkBool32 allowSamplerImageViewPostSubmitCreation + VkDeviceSize descriptorBufferOffsetAlignment + uint32_t maxDescriptorBufferBindings + uint32_t maxResourceDescriptorBufferBindings + uint32_t maxSamplerDescriptorBufferBindings + uint32_t maxEmbeddedImmutableSamplerBindings + uint32_t maxEmbeddedImmutableSamplers + size_t bufferCaptureReplayDescriptorDataSize + size_t imageCaptureReplayDescriptorDataSize + size_t imageViewCaptureReplayDescriptorDataSize + size_t samplerCaptureReplayDescriptorDataSize + size_t accelerationStructureCaptureReplayDescriptorDataSize + size_t samplerDescriptorSize + size_t combinedImageSamplerDescriptorSize + size_t sampledImageDescriptorSize + size_t storageImageDescriptorSize + size_t uniformTexelBufferDescriptorSize + size_t robustUniformTexelBufferDescriptorSize + size_t storageTexelBufferDescriptorSize + size_t robustStorageTexelBufferDescriptorSize + size_t uniformBufferDescriptorSize + size_t robustUniformBufferDescriptorSize + size_t storageBufferDescriptorSize + size_t robustStorageBufferDescriptorSize + size_t inputAttachmentDescriptorSize + size_t accelerationStructureDescriptorSize + VkDeviceSize maxSamplerDescriptorBufferRange + VkDeviceSize maxResourceDescriptorBufferRange + VkDeviceSize samplerDescriptorBufferAddressSpaceSize + VkDeviceSize resourceDescriptorBufferAddressSpaceSize + VkDeviceSize descriptorBufferAddressSpaceSize + + + VkStructureType sType + void* pNext + size_t combinedImageSamplerDensityMapDescriptorSize + + + VkStructureType sType + void* pNext + VkDeviceAddress address + VkDeviceSize range + VkFormat format + + + VkStructureType sType + void* pNext + VkDeviceAddress address + VkBufferUsageFlags usage + + + VkStructureType sType + void* pNext + VkBuffer buffer + + + const VkSampler* pSampler + const VkDescriptorImageInfo* pCombinedImageSampler + const VkDescriptorImageInfo* pInputAttachmentImage + const VkDescriptorImageInfo* pSampledImage + const VkDescriptorImageInfo* pStorageImage + const VkDescriptorAddressInfoEXT* pUniformTexelBuffer + const VkDescriptorAddressInfoEXT* pStorageTexelBuffer + const VkDescriptorAddressInfoEXT* pUniformBuffer + const VkDescriptorAddressInfoEXT* pStorageBuffer + VkDeviceAddress accelerationStructure + + + VkStructureType sType + const void* pNext + VkDescriptorType type + VkDescriptorDataEXT data + + + VkStructureType sType + const void* pNext + VkBuffer buffer + + + VkStructureType sType + const void* pNext + VkImage image + + + VkStructureType sType + const void* pNext + VkImageView imageView + + + VkStructureType sType + const void* pNext + VkSampler sampler + + + VkStructureType sType + const void* pNext + VkAccelerationStructureKHR accelerationStructure + VkAccelerationStructureNV accelerationStructureNV + + + VkStructureType sType + const void* pNext + const void* opaqueCaptureDescriptorData + + + VkStructureType sType + void* pNext + VkBool32 shaderIntegerDotProduct + + + + VkStructureType sType + void* pNext + VkBool32 integerDotProduct8BitUnsignedAccelerated + VkBool32 integerDotProduct8BitSignedAccelerated + VkBool32 integerDotProduct8BitMixedSignednessAccelerated + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated + VkBool32 integerDotProduct16BitUnsignedAccelerated + VkBool32 integerDotProduct16BitSignedAccelerated + VkBool32 integerDotProduct16BitMixedSignednessAccelerated + VkBool32 integerDotProduct32BitUnsignedAccelerated + VkBool32 integerDotProduct32BitSignedAccelerated + VkBool32 integerDotProduct32BitMixedSignednessAccelerated + VkBool32 integerDotProduct64BitUnsignedAccelerated + VkBool32 integerDotProduct64BitSignedAccelerated + VkBool32 integerDotProduct64BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated + + + + VkStructureType sType + void* pNext + VkBool32 hasPrimary + VkBool32 hasRender + int64_t primaryMajor + int64_t primaryMinor + int64_t renderMajor + int64_t renderMinor + + + VkStructureType sType + void* pNext + VkBool32 fragmentShaderBarycentric + + + VkStructureType sType + void* pNext + VkBool32 triStripVertexOrderIndependentOfProvokingVertex + + + VkStructureType sType + void* pNext + VkBool32 rayTracingMotionBlur + VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect + + + + VkStructureType sType + const void* pNext + VkDeviceOrHostAddressConstKHR vertexData + + + VkStructureType sType + const void* pNext + uint32_t maxInstances + VkAccelerationStructureMotionInfoFlagsNV flags + + + float sx + float a + float b + float pvx + float sy + float c + float pvy + float sz + float pvz + float qx + float qy + float qz + float qw + float tx + float ty + float tz + + + The bitfields in this structure are non-normative since bitfield ordering is implementation-defined in C. The specification defines the normative layout. + VkSRTDataNV transformT0 + VkSRTDataNV transformT1 + uint32_t instanceCustomIndex:24 + uint32_t mask:8 + uint32_t instanceShaderBindingTableRecordOffset:24 + VkGeometryInstanceFlagsKHR flags:8 + uint64_t accelerationStructureReference + + + The bitfields in this structure are non-normative since bitfield ordering is implementation-defined in C. The specification defines the normative layout. + VkTransformMatrixKHR transformT0 + VkTransformMatrixKHR transformT1 + uint32_t instanceCustomIndex:24 + uint32_t mask:8 + uint32_t instanceShaderBindingTableRecordOffset:24 + VkGeometryInstanceFlagsKHR flags:8 + uint64_t accelerationStructureReference + + + VkAccelerationStructureInstanceKHR staticInstance + VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance + VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance + + + VkAccelerationStructureMotionInstanceTypeNV type + VkAccelerationStructureMotionInstanceFlagsNV flags + VkAccelerationStructureMotionInstanceDataNV data + + typedef void* VkRemoteAddressNV; + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagBits handleType + + + VkStructureType sType + const void* pNext + VkBufferCollectionFUCHSIA collection + uint32_t index + + + VkStructureType sType + const void* pNext + VkBufferCollectionFUCHSIA collection + uint32_t index + + + VkStructureType sType + const void* pNext + VkBufferCollectionFUCHSIA collection + uint32_t index + + + VkStructureType sType + const void* pNext + zx_handle_t collectionToken + + + VkStructureType sType + void* pNext + uint32_t memoryTypeBits + uint32_t bufferCount + uint32_t createInfoIndex + uint64_t sysmemPixelFormat + VkFormatFeatureFlags formatFeatures + VkSysmemColorSpaceFUCHSIA sysmemColorSpaceIndex + VkComponentMapping samplerYcbcrConversionComponents + VkSamplerYcbcrModelConversion suggestedYcbcrModel + VkSamplerYcbcrRange suggestedYcbcrRange + VkChromaLocation suggestedXChromaOffset + VkChromaLocation suggestedYChromaOffset + + + VkStructureType sType + const void* pNext + VkBufferCreateInfo createInfo + VkFormatFeatureFlags requiredFormatFeatures + VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints + + + VkStructureType sType + const void* pNext + uint32_t colorSpace + + + VkStructureType sType + const void* pNext + VkImageCreateInfo imageCreateInfo + VkFormatFeatureFlags requiredFormatFeatures + VkImageFormatConstraintsFlagsFUCHSIA flags + uint64_t sysmemPixelFormat + uint32_t colorSpaceCount + const VkSysmemColorSpaceFUCHSIA* pColorSpaces + + + VkStructureType sType + const void* pNext + uint32_t formatConstraintsCount + const VkImageFormatConstraintsInfoFUCHSIA* pFormatConstraints + VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints + VkImageConstraintsInfoFlagsFUCHSIA flags + + + VkStructureType sType + const void* pNext + uint32_t minBufferCount + uint32_t maxBufferCount + uint32_t minBufferCountForCamping + uint32_t minBufferCountForDedicatedSlack + uint32_t minBufferCountForSharedSlack + + + VkStructureType sType + void* pNext + VkBool32 formatRgba10x6WithoutYCbCrSampler + + + VkStructureType sType + void* pNext + VkFormatFeatureFlags2 linearTilingFeatures + VkFormatFeatureFlags2 optimalTilingFeatures + VkFormatFeatureFlags2 bufferFeatures + + + + VkStructureType sType + void* pNext + uint32_t drmFormatModifierCount + VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties + + + uint64_t drmFormatModifier + uint32_t drmFormatModifierPlaneCount + VkFormatFeatureFlags2 drmFormatModifierTilingFeatures + + + VkStructureType sType + void* pNext + VkFormat format + uint64_t externalFormat + VkFormatFeatureFlags2 formatFeatures + VkComponentMapping samplerYcbcrConversionComponents + VkSamplerYcbcrModelConversion suggestedYcbcrModel + VkSamplerYcbcrRange suggestedYcbcrRange + VkChromaLocation suggestedXChromaOffset + VkChromaLocation suggestedYChromaOffset + + + VkStructureType sType + const void* pNext + uint32_t viewMask + uint32_t colorAttachmentCount + const VkFormat* pColorAttachmentFormats + VkFormat depthAttachmentFormat + VkFormat stencilAttachmentFormat + + + + VkStructureType sType + const void* pNext + VkRenderingFlags flags + VkRect2D renderArea + uint32_t layerCount + uint32_t viewMask + uint32_t colorAttachmentCount + const VkRenderingAttachmentInfo* pColorAttachments + const VkRenderingAttachmentInfo* pDepthAttachment + const VkRenderingAttachmentInfo* pStencilAttachment + + + + VkStructureType sType + const void* pNext + VkImageView imageView + VkImageLayout imageLayout + VkResolveModeFlagBits resolveMode + VkImageView resolveImageView + VkImageLayout resolveImageLayout + VkAttachmentLoadOp loadOp + VkAttachmentStoreOp storeOp + VkClearValue clearValue + + + + VkStructureType sType + const void* pNext + VkImageView imageView + VkImageLayout imageLayout + VkExtent2D shadingRateAttachmentTexelSize + + + VkStructureType sType + const void* pNext + VkImageView imageView + VkImageLayout imageLayout + + + VkStructureType sType + void* pNext + VkBool32 dynamicRendering + + + + VkStructureType sType + const void* pNext + VkRenderingFlags flags + uint32_t viewMask + uint32_t colorAttachmentCount + uint32_t colorAttachmentCount + const VkFormat* pColorAttachmentFormats + VkFormat depthAttachmentFormat + VkFormat stencilAttachmentFormat + VkSampleCountFlagBits rasterizationSamples + + + + VkStructureType sType + const void* pNext + uint32_t colorAttachmentCount + const VkSampleCountFlagBits* pColorAttachmentSamples + VkSampleCountFlagBits depthStencilAttachmentSamples + + + + VkStructureType sType + const void* pNext + VkBool32 perViewAttributes + VkBool32 perViewAttributesPositionXOnly + + + VkStructureType sType + void* pNext + VkBool32 minLod + + + VkStructureType sType + const void* pNext + float minLod + + + VkStructureType sType + void* pNext + VkBool32 rasterizationOrderColorAttachmentAccess + VkBool32 rasterizationOrderDepthAttachmentAccess + VkBool32 rasterizationOrderStencilAttachmentAccess + + + + VkStructureType sType + void* pNext + VkBool32 linearColorAttachment + + + VkStructureType sType + void* pNext + VkBool32 graphicsPipelineLibrary + + + VkStructureType sType + void* pNext + VkBool32 graphicsPipelineLibraryFastLinking + VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration + + + VkStructureType sType + void* pNext + VkGraphicsPipelineLibraryFlagsEXT flags + + + VkStructureType sType + void* pNext + VkBool32 descriptorSetHostMapping + + + VkStructureType sType + const void* pNext + VkDescriptorSetLayout descriptorSetLayout + uint32_t binding + + + VkStructureType sType + void* pNext + size_t descriptorOffset + uint32_t descriptorSize + + + VkStructureType sType + void* pNext + VkBool32 shaderModuleIdentifier + + + VkStructureType sType + void* pNext + uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE] + + + VkStructureType sType + const void* pNext + uint32_t identifierSize + const uint8_t* pIdentifier + + + VkStructureType sType + void* pNext + uint32_t identifierSize + uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT] + + + VkStructureType sType + const void* pNext + VkImageCompressionFlagsEXT flags + uint32_t compressionControlPlaneCount + VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags + + + VkStructureType sType + void* pNext + VkBool32 imageCompressionControl + + + VkStructureType sType + void* pNext + VkImageCompressionFlagsEXT imageCompressionFlags + VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags + + + VkStructureType sType + void* pNext + VkBool32 imageCompressionControlSwapchain + + + VkStructureType sType + void* pNext + VkImageSubresource imageSubresource + + + VkStructureType sType + void* pNext + VkSubresourceLayout subresourceLayout + + + VkStructureType sType + const void* pNext + VkBool32 disallowMerging + + + uint32_t postMergeSubpassCount + + + VkStructureType sType + const void* pNext + VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback + + + VkSubpassMergeStatusEXT subpassMergeStatus + char description[VK_MAX_DESCRIPTION_SIZE] + uint32_t postMergeIndex + + + VkStructureType sType + const void* pNext + VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback + + + VkStructureType sType + void* pNext + VkBool32 subpassMergeFeedback + + + VkStructureType sType + const void* pNext + VkMicromapTypeEXT type + VkBuildMicromapFlagsEXT flags + VkBuildMicromapModeEXT mode + VkMicromapEXT dstMicromap + uint32_t usageCountsCount + const VkMicromapUsageEXT* pUsageCounts + const VkMicromapUsageEXT* const* ppUsageCounts + VkDeviceOrHostAddressConstKHR data + VkDeviceOrHostAddressKHR scratchData + VkDeviceOrHostAddressConstKHR triangleArray + VkDeviceSize triangleArrayStride + + + VkStructureType sType + const void* pNext + VkMicromapCreateFlagsEXT createFlags + VkBuffer buffer + VkDeviceSize offsetSpecified in bytes + VkDeviceSize size + VkMicromapTypeEXT type + VkDeviceAddress deviceAddress + + + VkStructureType sType + const void* pNext + const uint8_t* pVersionData + + + VkStructureType sType + const void* pNext + VkMicromapEXT src + VkMicromapEXT dst + VkCopyMicromapModeEXT mode + + + VkStructureType sType + const void* pNext + VkMicromapEXT src + VkDeviceOrHostAddressKHR dst + VkCopyMicromapModeEXT mode + + + VkStructureType sType + const void* pNext + VkDeviceOrHostAddressConstKHR src + VkMicromapEXT dst + VkCopyMicromapModeEXT mode + + + VkStructureType sType + const void* pNext + VkDeviceSize micromapSize + VkDeviceSize buildScratchSize + VkBool32 discardable + + + uint32_t count + uint32_t subdivisionLevel + uint32_t formatInterpretation depends on parent type + + + uint32_t dataOffsetSpecified in bytes + uint16_t subdivisionLevel + uint16_t format + + + VkStructureType sType + void* pNext + VkBool32 micromap + VkBool32 micromapCaptureReplay + VkBool32 micromapHostCommands + + + VkStructureType sType + void* pNext + uint32_t maxOpacity2StateSubdivisionLevel + uint32_t maxOpacity4StateSubdivisionLevel + + + VkStructureType sType + void* pNext + VkIndexType indexType + VkDeviceOrHostAddressConstKHR indexBuffer + VkDeviceSize indexStride + uint32_t baseTriangle + uint32_t usageCountsCount + const VkMicromapUsageEXT* pUsageCounts + const VkMicromapUsageEXT* const* ppUsageCounts + VkMicromapEXT micromap + + + VkStructureType sType + void* pNext + VkBool32 displacementMicromap + + + VkStructureType sType + void* pNext + uint32_t maxDisplacementMicromapSubdivisionLevel + + + VkStructureType sType + void* pNext + + VkFormat displacementBiasAndScaleFormat + VkFormat displacementVectorFormat + + VkDeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer + VkDeviceSize displacementBiasAndScaleStride + VkDeviceOrHostAddressConstKHR displacementVectorBuffer + VkDeviceSize displacementVectorStride + VkDeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags + VkDeviceSize displacedMicromapPrimitiveFlagsStride + VkIndexType indexType + VkDeviceOrHostAddressConstKHR indexBuffer + VkDeviceSize indexStride + + uint32_t baseTriangle + + uint32_t usageCountsCount + const VkMicromapUsageEXT* pUsageCounts + const VkMicromapUsageEXT* const* ppUsageCounts + + VkMicromapEXT micromap + + + VkStructureType sType + void* pNext + uint8_t pipelineIdentifier[VK_UUID_SIZE] + + + VkStructureType sType + void* pNext + VkBool32 pipelinePropertiesIdentifier + + + VkStructureType sType + void* pNext + VkBool32 shaderEarlyAndLateFragmentTests + + + VkStructureType sType + const void* pNext + VkExportMetalObjectTypeFlagBitsEXT exportObjectType + + + VkStructureType sType + const void* pNext + + + VkStructureType sType + const void* pNext + MTLDevice_id mtlDevice + + + VkStructureType sType + const void* pNext + VkQueue queue + MTLCommandQueue_id mtlCommandQueue + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + MTLBuffer_id mtlBuffer + + + VkStructureType sType + const void* pNext + MTLBuffer_id mtlBuffer + + + VkStructureType sType + const void* pNext + VkImage image + VkImageView imageView + VkBufferView bufferView + VkImageAspectFlagBits plane + MTLTexture_id mtlTexture + + + VkStructureType sType + const void* pNext + VkImageAspectFlagBits plane + MTLTexture_id mtlTexture + + + VkStructureType sType + const void* pNext + VkImage image + IOSurfaceRef ioSurface + + + VkStructureType sType + const void* pNext + IOSurfaceRef ioSurface + + + VkStructureType sType + const void* pNext + VkSemaphore semaphore + VkEvent event + MTLSharedEvent_id mtlSharedEvent + + + VkStructureType sType + const void* pNext + MTLSharedEvent_id mtlSharedEvent + + + VkStructureType sType + void* pNext + VkBool32 nonSeamlessCubeMap + + + VkStructureType sType + void* pNext + VkBool32 pipelineRobustness + + + VkStructureType sType + const void* pNext + VkPipelineRobustnessBufferBehaviorEXT storageBuffers + VkPipelineRobustnessBufferBehaviorEXT uniformBuffers + VkPipelineRobustnessBufferBehaviorEXT vertexInputs + VkPipelineRobustnessImageBehaviorEXT images + + + VkStructureType sType + void* pNext + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs + VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages + + + VkStructureType sType + const void* pNext + VkOffset2D filterCenter + VkExtent2D filterSize + uint32_t numPhases + + + VkStructureType sType + void* pNext + VkBool32 textureSampleWeighted + VkBool32 textureBoxFilter + VkBool32 textureBlockMatch + + + VkStructureType sType + void* pNext + uint32_t maxWeightFilterPhases + VkExtent2D maxWeightFilterDimension + VkExtent2D maxBlockMatchRegion + VkExtent2D maxBoxFilterBlockSize + + + VkStructureType sType + void* pNext + VkBool32 tileProperties + + + VkStructureType sType + void* pNext + VkExtent3D tileSize + VkExtent2D apronSize + VkOffset2D origin + + + VkStructureType sType + void* pNext + VkBool32 amigoProfiling + + + VkStructureType sType + const void* pNext + uint64_t firstDrawTimestamp + uint64_t swapBufferTimestamp + + + VkStructureType sType + void* pNext + VkBool32 attachmentFeedbackLoopLayout + + + VkStructureType sType + void* pNext + VkBool32 depthClampZeroOne + + + VkStructureType sType + void* pNext + VkBool32 reportAddressBinding + + + VkStructureType sType + void* pNext + VkDeviceAddressBindingFlagsEXT flags + VkDeviceAddress baseAddress + VkDeviceSize size + VkDeviceAddressBindingTypeEXT bindingType + + + VkStructureType sType + void* pNext + VkBool32 opticalFlow + + + VkStructureType sType + void* pNext + VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes + VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes + VkBool32 hintSupported + VkBool32 costSupported + VkBool32 bidirectionalFlowSupported + VkBool32 globalFlowSupported + uint32_t minWidth + uint32_t minHeight + uint32_t maxWidth + uint32_t maxHeight + uint32_t maxNumRegionsOfInterest + + + VkStructureType sType + const void* pNext + VkOpticalFlowUsageFlagsNV usage + + + VkStructureType sType + const void* pNext + VkFormat format + + + VkStructureType sType + void* pNext + uint32_t width + uint32_t height + VkFormat imageFormat + VkFormat flowVectorFormat + VkFormat costFormat + VkOpticalFlowGridSizeFlagsNV outputGridSize + VkOpticalFlowGridSizeFlagsNV hintGridSize + VkOpticalFlowPerformanceLevelNV performanceLevel + VkOpticalFlowSessionCreateFlagsNV flags + + NV internal use only + VkStructureType sType + void* pNext + uint32_t id + uint32_t size + const void* pPrivateData + + + VkStructureType sType + void* pNext + VkOpticalFlowExecuteFlagsNV flags + uint32_t regionCount + const VkRect2D* pRegions + + + VkStructureType sType + void* pNext + VkBool32 deviceFault + VkBool32 deviceFaultVendorBinary + + + VkDeviceFaultAddressTypeEXT addressType + VkDeviceAddress reportedAddress + VkDeviceSize addressPrecision + + + char description[VK_MAX_DESCRIPTION_SIZE]Free-form description of the fault + uint64_t vendorFaultCode + uint64_t vendorFaultData + + + VkStructureType sType + void* pNext + uint32_t addressInfoCount + uint32_t vendorInfoCount + VkDeviceSize vendorBinarySizeSpecified in bytes + + + VkStructureType sType + void* pNext + char description[VK_MAX_DESCRIPTION_SIZE]Free-form description of the fault + VkDeviceFaultAddressInfoEXT* pAddressInfos + VkDeviceFaultVendorInfoEXT* pVendorInfos + void* pVendorBinaryData + + + The fields in this structure are non-normative since structure packing is implementation-defined in C. The specification defines the normative layout. + uint32_t headerSize + VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion + uint32_t vendorID + uint32_t deviceID + uint32_t driverVersion + uint8_t pipelineCacheUUID[VK_UUID_SIZE] + uint32_t applicationNameOffset + uint32_t applicationVersion + uint32_t engineNameOffset + uint32_t engineVersion + uint32_t apiVersion + + + VkStructureType sType + void* pNext + VkBool32 pipelineLibraryGroupHandles + + + VkDeviceAddress srcAddress + VkDeviceAddress dstAddress + VkDeviceSize compressedSizeSpecified in bytes + VkDeviceSize decompressedSizeSpecified in bytes + VkMemoryDecompressionMethodFlagsNV decompressionMethod + + + VkStructureType sType + void* pNext + uint64_t shaderCoreMask + uint32_t shaderCoreCount + uint32_t shaderWarpsPerCore + + + VkStructureType sType + void* pNext + VkBool32 shaderCoreBuiltins + + + VkStructureType sType + void* pNext + VkPresentModeKHR presentMode + + + VkStructureType sType + void* pNext + VkPresentScalingFlagsEXT supportedPresentScaling + VkPresentGravityFlagsEXT supportedPresentGravityX + VkPresentGravityFlagsEXT supportedPresentGravityY + VkExtent2D minScaledImageExtentSupported minimum image width and height for the surface when scaling is used + VkExtent2D maxScaledImageExtentSupported maximum image width and height for the surface when scaling is used + + + VkStructureType sType + void* pNext + uint32_t presentModeCount + VkPresentModeKHR* pPresentModesOutput list of present modes compatible with the one specified in VkSurfacePresentModeEXT + + + VkStructureType sType + void* pNext + VkBool32 swapchainMaintenance1 + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const VkFence* pFencesFence to signal for each swapchain + + + VkStructureType sType + const void* pNext + uint32_t presentModeCountLength of the pPresentModes array + const VkPresentModeKHR* pPresentModesPresentation modes which will be usable with this swapchain + + + VkStructureType sType + const void* pNext + uint32_t swapchainCountCopy of VkPresentInfoKHR::swapchainCount + const VkPresentModeKHR* pPresentModesPresentation mode for each swapchain + + + VkStructureType sType + const void* pNext + VkPresentScalingFlagsEXT scalingBehavior + VkPresentGravityFlagsEXT presentGravityX + VkPresentGravityFlagsEXT presentGravityY + + + VkStructureType sType + const void* pNext + VkSwapchainKHR swapchainSwapchain for which images are being released + uint32_t imageIndexCountNumber of indices to release + const uint32_t* pImageIndicesIndices of which presentable images to release + + + VkStructureType sType + void* pNext + VkBool32 rayTracingInvocationReorder + + + VkStructureType sType + void* pNext + VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint + + + VkStructureType sType + void* pNext + VkDirectDriverLoadingFlagsLUNARG flags + PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr + + + VkStructureType sType + void* pNext + VkDirectDriverLoadingModeLUNARG mode + uint32_t driverCount + const VkDirectDriverLoadingInfoLUNARG* pDrivers + + + VkStructureType sType + void* pNext + VkBool32 multiviewPerViewViewports + + + VkStructureType sType + void* pNext + uint32_t pixelRate + uint32_t texelRate + uint32_t fmaRate + + + VkStructureType sType + void* pNext + VkBool32 multiviewPerViewRenderAreas + + + VkStructureType sType + const void* pNext + uint32_t perViewRenderAreaCount + const VkRect2D* pPerViewRenderAreas + + + VkStructureType sType + const void* pNext + void* pQueriedLowLatencyData + + + VkStructureType sType + const void* pNext + VkMemoryMapFlags flags + VkDeviceMemory memory + VkDeviceSize offset + VkDeviceSize size + + + VkStructureType sType + const void* pNext + VkMemoryUnmapFlagsKHR flags + VkDeviceMemory memory + + + VkStructureType sType + void* pNext + VkBool32 shaderObject + + + VkStructureType sType + void* pNext + uint8_t shaderBinaryUUID[VK_UUID_SIZE] + uint32_t shaderBinaryVersion + + + VkStructureType sType + const void* pNext + VkShaderCreateFlagsEXT flags + VkShaderStageFlagBits stage + VkShaderStageFlags nextStage + VkShaderCodeTypeEXT codeType + size_t codeSize + const void* pCode + const char* pName + uint32_t setLayoutCount + const VkDescriptorSetLayout* pSetLayouts + uint32_t pushConstantRangeCount + const VkPushConstantRange* pPushConstantRanges + const VkSpecializationInfo* pSpecializationInfo + + + VkStructureType sType + void* pNext + VkBool32 shaderTileImageColorReadAccess + VkBool32 shaderTileImageDepthReadAccess + VkBool32 shaderTileImageStencilReadAccess + + + VkStructureType sType + void* pNext + VkBool32 shaderTileImageCoherentReadAccelerated + VkBool32 shaderTileImageReadSampleFromPixelRateInvocation + VkBool32 shaderTileImageReadFromHelperInvocation + + + + + Vulkan enumerant (token) definitions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Unlike OpenGL, most tokens in Vulkan are actual typed enumerants in + their own numeric namespaces. The "name" attribute is the C enum + type name, and is pulled in from a type tag definition above + (slightly clunky, but retains the type / enum distinction). "type" + attributes of "enum" or "bitmask" indicate that these values should + be generated inside an appropriate definition. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + value="4" reserved for VK_KHR_sampler_mirror_clamp_to_edge + enum VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; do not + alias! + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Return codes (positive values) + + + + + + + Error codes (negative values) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Flags + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + WSI Extensions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + NVX_device_generated_commands formerly used these enum values, but that extension has been removed + value 31 / name VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT + value 32 / name VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Vendor IDs are now represented as enums instead of the old + <vendorids> tag, allowing them to be included in the + API headers. + + + + + + + + + + + Driver IDs are now represented as enums instead of the old + <driverids> tag, allowing them to be included in the + API headers. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + bitpos 17-31 are specified by extensions to the original VkAccessFlagBits enum + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + bitpos 17-31 are specified by extensions to the original VkPipelineStageFlagBits enum + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VkResult vkCreateInstance + const VkInstanceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkInstance* pInstance + + + void vkDestroyInstance + VkInstance instance + const VkAllocationCallbacks* pAllocator + + all sname:VkPhysicalDevice objects enumerated from pname:instance + + + + VkResult vkEnumeratePhysicalDevices + VkInstance instance + uint32_t* pPhysicalDeviceCount + VkPhysicalDevice* pPhysicalDevices + + + PFN_vkVoidFunction vkGetDeviceProcAddr + VkDevice device + const char* pName + + + PFN_vkVoidFunction vkGetInstanceProcAddr + VkInstance instance + const char* pName + + + void vkGetPhysicalDeviceProperties + VkPhysicalDevice physicalDevice + VkPhysicalDeviceProperties* pProperties + + + void vkGetPhysicalDeviceQueueFamilyProperties + VkPhysicalDevice physicalDevice + uint32_t* pQueueFamilyPropertyCount + VkQueueFamilyProperties* pQueueFamilyProperties + + + void vkGetPhysicalDeviceMemoryProperties + VkPhysicalDevice physicalDevice + VkPhysicalDeviceMemoryProperties* pMemoryProperties + + + void vkGetPhysicalDeviceFeatures + VkPhysicalDevice physicalDevice + VkPhysicalDeviceFeatures* pFeatures + + + void vkGetPhysicalDeviceFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkFormatProperties* pFormatProperties + + + VkResult vkGetPhysicalDeviceImageFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + VkImageFormatProperties* pImageFormatProperties + + + VkResult vkCreateDevice + VkPhysicalDevice physicalDevice + const VkDeviceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDevice* pDevice + + + VkResult vkCreateDevice + VkPhysicalDevice physicalDevice + const VkDeviceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDevice* pDevice + + + void vkDestroyDevice + VkDevice device + const VkAllocationCallbacks* pAllocator + + all sname:VkQueue objects created from pname:device + + + + VkResult vkEnumerateInstanceVersion + uint32_t* pApiVersion + + + VkResult vkEnumerateInstanceLayerProperties + uint32_t* pPropertyCount + VkLayerProperties* pProperties + + + VkResult vkEnumerateInstanceExtensionProperties + const char* pLayerName + uint32_t* pPropertyCount + VkExtensionProperties* pProperties + + + VkResult vkEnumerateDeviceLayerProperties + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkLayerProperties* pProperties + + + VkResult vkEnumerateDeviceLayerProperties + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkLayerProperties* pProperties + + + VkResult vkEnumerateDeviceExtensionProperties + VkPhysicalDevice physicalDevice + const char* pLayerName + uint32_t* pPropertyCount + VkExtensionProperties* pProperties + + + void vkGetDeviceQueue + VkDevice device + uint32_t queueFamilyIndex + uint32_t queueIndex + VkQueue* pQueue + + + VkResult vkQueueSubmit + VkQueue queue + uint32_t submitCount + const VkSubmitInfo* pSubmits + VkFence fence + + + VkResult vkQueueWaitIdle + VkQueue queue + + + VkResult vkDeviceWaitIdle + VkDevice device + + all sname:VkQueue objects created from pname:device + + + + VkResult vkAllocateMemory + VkDevice device + const VkMemoryAllocateInfo* pAllocateInfo + const VkAllocationCallbacks* pAllocator + VkDeviceMemory* pMemory + + + void vkFreeMemory + VkDevice device + VkDeviceMemory memory + const VkAllocationCallbacks* pAllocator + + + VkResult vkMapMemory + VkDevice device + VkDeviceMemory memory + VkDeviceSize offset + VkDeviceSize size + VkMemoryMapFlags flags + void** ppData + + + void vkUnmapMemory + VkDevice device + VkDeviceMemory memory + + + VkResult vkFlushMappedMemoryRanges + VkDevice device + uint32_t memoryRangeCount + const VkMappedMemoryRange* pMemoryRanges + + + VkResult vkInvalidateMappedMemoryRanges + VkDevice device + uint32_t memoryRangeCount + const VkMappedMemoryRange* pMemoryRanges + + + void vkGetDeviceMemoryCommitment + VkDevice device + VkDeviceMemory memory + VkDeviceSize* pCommittedMemoryInBytes + + + void vkGetBufferMemoryRequirements + VkDevice device + VkBuffer buffer + VkMemoryRequirements* pMemoryRequirements + + + VkResult vkBindBufferMemory + VkDevice device + VkBuffer buffer + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + void vkGetImageMemoryRequirements + VkDevice device + VkImage image + VkMemoryRequirements* pMemoryRequirements + + + VkResult vkBindImageMemory + VkDevice device + VkImage image + VkDeviceMemory memory + VkDeviceSize memoryOffset + + + void vkGetImageSparseMemoryRequirements + VkDevice device + VkImage image + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements* pSparseMemoryRequirements + + + void vkGetPhysicalDeviceSparseImageFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkSampleCountFlagBits samples + VkImageUsageFlags usage + VkImageTiling tiling + uint32_t* pPropertyCount + VkSparseImageFormatProperties* pProperties + + + VkResult vkQueueBindSparse + VkQueue queue + uint32_t bindInfoCount + const VkBindSparseInfo* pBindInfo + VkFence fence + + + VkResult vkCreateFence + VkDevice device + const VkFenceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + void vkDestroyFence + VkDevice device + VkFence fence + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetFences + VkDevice device + uint32_t fenceCount + const VkFence* pFences + + + VkResult vkGetFenceStatus + VkDevice device + VkFence fence + + + VkResult vkWaitForFences + VkDevice device + uint32_t fenceCount + const VkFence* pFences + VkBool32 waitAll + uint64_t timeout + + + VkResult vkCreateSemaphore + VkDevice device + const VkSemaphoreCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSemaphore* pSemaphore + + + void vkDestroySemaphore + VkDevice device + VkSemaphore semaphore + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateEvent + VkDevice device + const VkEventCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkEvent* pEvent + + + void vkDestroyEvent + VkDevice device + VkEvent event + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetEventStatus + VkDevice device + VkEvent event + + + VkResult vkSetEvent + VkDevice device + VkEvent event + + + VkResult vkResetEvent + VkDevice device + VkEvent event + + + VkResult vkCreateQueryPool + VkDevice device + const VkQueryPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkQueryPool* pQueryPool + + + void vkDestroyQueryPool + VkDevice device + VkQueryPool queryPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetQueryPoolResults + VkDevice device + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + size_t dataSize + void* pData + VkDeviceSize stride + VkQueryResultFlags flags + + + void vkResetQueryPool + VkDevice device + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + + + + VkResult vkCreateBuffer + VkDevice device + const VkBufferCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBuffer* pBuffer + + + void vkDestroyBuffer + VkDevice device + VkBuffer buffer + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateBufferView + VkDevice device + const VkBufferViewCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBufferView* pView + + + void vkDestroyBufferView + VkDevice device + VkBufferView bufferView + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateImage + VkDevice device + const VkImageCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkImage* pImage + + + void vkDestroyImage + VkDevice device + VkImage image + const VkAllocationCallbacks* pAllocator + + + void vkGetImageSubresourceLayout + VkDevice device + VkImage image + const VkImageSubresource* pSubresource + VkSubresourceLayout* pLayout + + + VkResult vkCreateImageView + VkDevice device + const VkImageViewCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkImageView* pView + + + void vkDestroyImageView + VkDevice device + VkImageView imageView + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateShaderModule + VkDevice device + const VkShaderModuleCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkShaderModule* pShaderModule + + + void vkDestroyShaderModule + VkDevice device + VkShaderModule shaderModule + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreatePipelineCache + VkDevice device + const VkPipelineCacheCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPipelineCache* pPipelineCache + + + VkResult vkCreatePipelineCache + VkDevice device + const VkPipelineCacheCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPipelineCache* pPipelineCache + + + void vkDestroyPipelineCache + VkDevice device + VkPipelineCache pipelineCache + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetPipelineCacheData + VkDevice device + VkPipelineCache pipelineCache + size_t* pDataSize + void* pData + + + VkResult vkMergePipelineCaches + VkDevice device + VkPipelineCache dstCache + uint32_t srcCacheCount + const VkPipelineCache* pSrcCaches + + + VkResult vkCreateGraphicsPipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkGraphicsPipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkCreateGraphicsPipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkGraphicsPipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkCreateComputePipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkComputePipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkCreateComputePipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkComputePipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI + VkDevice device + VkRenderPass renderpass + VkExtent2D* pMaxWorkgroupSize + + + void vkDestroyPipeline + VkDevice device + VkPipeline pipeline + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreatePipelineLayout + VkDevice device + const VkPipelineLayoutCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPipelineLayout* pPipelineLayout + + + void vkDestroyPipelineLayout + VkDevice device + VkPipelineLayout pipelineLayout + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateSampler + VkDevice device + const VkSamplerCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSampler* pSampler + + + void vkDestroySampler + VkDevice device + VkSampler sampler + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateDescriptorSetLayout + VkDevice device + const VkDescriptorSetLayoutCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorSetLayout* pSetLayout + + + void vkDestroyDescriptorSetLayout + VkDevice device + VkDescriptorSetLayout descriptorSetLayout + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateDescriptorPool + VkDevice device + const VkDescriptorPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorPool* pDescriptorPool + + + void vkDestroyDescriptorPool + VkDevice device + VkDescriptorPool descriptorPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetDescriptorPool + VkDevice device + VkDescriptorPool descriptorPool + VkDescriptorPoolResetFlags flags + + any sname:VkDescriptorSet objects allocated from pname:descriptorPool + + + + VkResult vkAllocateDescriptorSets + VkDevice device + const VkDescriptorSetAllocateInfo* pAllocateInfo + VkDescriptorSet* pDescriptorSets + + + VkResult vkFreeDescriptorSets + VkDevice device + VkDescriptorPool descriptorPool + uint32_t descriptorSetCount + const VkDescriptorSet* pDescriptorSets + + + void vkUpdateDescriptorSets + VkDevice device + uint32_t descriptorWriteCount + const VkWriteDescriptorSet* pDescriptorWrites + uint32_t descriptorCopyCount + const VkCopyDescriptorSet* pDescriptorCopies + + + VkResult vkCreateFramebuffer + VkDevice device + const VkFramebufferCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkFramebuffer* pFramebuffer + + + void vkDestroyFramebuffer + VkDevice device + VkFramebuffer framebuffer + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateRenderPass + VkDevice device + const VkRenderPassCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkRenderPass* pRenderPass + + + void vkDestroyRenderPass + VkDevice device + VkRenderPass renderPass + const VkAllocationCallbacks* pAllocator + + + void vkGetRenderAreaGranularity + VkDevice device + VkRenderPass renderPass + VkExtent2D* pGranularity + + + VkResult vkCreateCommandPool + VkDevice device + const VkCommandPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkCommandPool* pCommandPool + + + void vkDestroyCommandPool + VkDevice device + VkCommandPool commandPool + const VkAllocationCallbacks* pAllocator + + + VkResult vkResetCommandPool + VkDevice device + VkCommandPool commandPool + VkCommandPoolResetFlags flags + + + VkResult vkAllocateCommandBuffers + VkDevice device + const VkCommandBufferAllocateInfo* pAllocateInfo + VkCommandBuffer* pCommandBuffers + + + void vkFreeCommandBuffers + VkDevice device + VkCommandPool commandPool + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + + + VkResult vkBeginCommandBuffer + VkCommandBuffer commandBuffer + const VkCommandBufferBeginInfo* pBeginInfo + + the sname:VkCommandPool that pname:commandBuffer was allocated from + + + + VkResult vkEndCommandBuffer + VkCommandBuffer commandBuffer + + the sname:VkCommandPool that pname:commandBuffer was allocated from + + + + VkResult vkResetCommandBuffer + VkCommandBuffer commandBuffer + VkCommandBufferResetFlags flags + + the sname:VkCommandPool that pname:commandBuffer was allocated from + + + + void vkCmdBindPipeline + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipeline pipeline + + + void vkCmdSetViewport + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkViewport* pViewports + + + void vkCmdSetScissor + VkCommandBuffer commandBuffer + uint32_t firstScissor + uint32_t scissorCount + const VkRect2D* pScissors + + + void vkCmdSetLineWidth + VkCommandBuffer commandBuffer + float lineWidth + + + void vkCmdSetDepthBias + VkCommandBuffer commandBuffer + float depthBiasConstantFactor + float depthBiasClamp + float depthBiasSlopeFactor + + + void vkCmdSetBlendConstants + VkCommandBuffer commandBuffer + const float blendConstants[4] + + + void vkCmdSetDepthBounds + VkCommandBuffer commandBuffer + float minDepthBounds + float maxDepthBounds + + + void vkCmdSetStencilCompareMask + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t compareMask + + + void vkCmdSetStencilWriteMask + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t writeMask + + + void vkCmdSetStencilReference + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t reference + + + void vkCmdBindDescriptorSets + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout layout + uint32_t firstSet + uint32_t descriptorSetCount + const VkDescriptorSet* pDescriptorSets + uint32_t dynamicOffsetCount + const uint32_t* pDynamicOffsets + + + void vkCmdBindIndexBuffer + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkIndexType indexType + + + void vkCmdBindVertexBuffers + VkCommandBuffer commandBuffer + uint32_t firstBinding + uint32_t bindingCount + const VkBuffer* pBuffers + const VkDeviceSize* pOffsets + + + void vkCmdDraw + VkCommandBuffer commandBuffer + uint32_t vertexCount + uint32_t instanceCount + uint32_t firstVertex + uint32_t firstInstance + + + void vkCmdDrawIndexed + VkCommandBuffer commandBuffer + uint32_t indexCount + uint32_t instanceCount + uint32_t firstIndex + int32_t vertexOffset + uint32_t firstInstance + + + void vkCmdDrawMultiEXT + VkCommandBuffer commandBuffer + uint32_t drawCount + const VkMultiDrawInfoEXT* pVertexInfo + uint32_t instanceCount + uint32_t firstInstance + uint32_t stride + + + void vkCmdDrawMultiIndexedEXT + VkCommandBuffer commandBuffer + uint32_t drawCount + const VkMultiDrawIndexedInfoEXT* pIndexInfo + uint32_t instanceCount + uint32_t firstInstance + uint32_t stride + const int32_t* pVertexOffset + + + void vkCmdDrawIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + + void vkCmdDrawIndexedIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + + void vkCmdDispatch + VkCommandBuffer commandBuffer + uint32_t groupCountX + uint32_t groupCountY + uint32_t groupCountZ + + + void vkCmdDispatchIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + + + void vkCmdSubpassShadingHUAWEI + VkCommandBuffer commandBuffer + + + void vkCmdDrawClusterHUAWEI + VkCommandBuffer commandBuffer + uint32_t groupCountX + uint32_t groupCountY + uint32_t groupCountZ + + + void vkCmdDrawClusterIndirectHUAWEI + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + + + void vkCmdCopyBuffer + VkCommandBuffer commandBuffer + VkBuffer srcBuffer + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferCopy* pRegions + + + void vkCmdCopyImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageCopy* pRegions + + + void vkCmdBlitImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageBlit* pRegions + VkFilter filter + + + void vkCmdCopyBufferToImage + VkCommandBuffer commandBuffer + VkBuffer srcBuffer + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkBufferImageCopy* pRegions + + + void vkCmdCopyImageToBuffer + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferImageCopy* pRegions + + + void vkCmdCopyMemoryIndirectNV + VkCommandBuffer commandBuffer + VkDeviceAddress copyBufferAddress + uint32_t copyCount + uint32_t stride + + + void vkCmdCopyMemoryToImageIndirectNV + VkCommandBuffer commandBuffer + VkDeviceAddress copyBufferAddress + uint32_t copyCount + uint32_t stride + VkImage dstImage + VkImageLayout dstImageLayout + const VkImageSubresourceLayers* pImageSubresources + + + void vkCmdUpdateBuffer + VkCommandBuffer commandBuffer + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize dataSize + const void* pData + + + void vkCmdFillBuffer + VkCommandBuffer commandBuffer + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize size + uint32_t data + + + void vkCmdClearColorImage + VkCommandBuffer commandBuffer + VkImage image + VkImageLayout imageLayout + const VkClearColorValue* pColor + uint32_t rangeCount + const VkImageSubresourceRange* pRanges + + + void vkCmdClearDepthStencilImage + VkCommandBuffer commandBuffer + VkImage image + VkImageLayout imageLayout + const VkClearDepthStencilValue* pDepthStencil + uint32_t rangeCount + const VkImageSubresourceRange* pRanges + + + void vkCmdClearAttachments + VkCommandBuffer commandBuffer + uint32_t attachmentCount + const VkClearAttachment* pAttachments + uint32_t rectCount + const VkClearRect* pRects + + + void vkCmdResolveImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageResolve* pRegions + + + void vkCmdSetEvent + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags stageMask + + + void vkCmdResetEvent + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags stageMask + + + void vkCmdWaitEvents + VkCommandBuffer commandBuffer + uint32_t eventCount + const VkEvent* pEvents + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + uint32_t memoryBarrierCount + const VkMemoryBarrier* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier* pImageMemoryBarriers + + + void vkCmdPipelineBarrier + VkCommandBuffer commandBuffer + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkDependencyFlags dependencyFlags + uint32_t memoryBarrierCount + const VkMemoryBarrier* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier* pImageMemoryBarriers + + + void vkCmdBeginQuery + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + VkQueryControlFlags flags + + + void vkCmdEndQuery + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + + + void vkCmdBeginConditionalRenderingEXT + VkCommandBuffer commandBuffer + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin + + + void vkCmdEndConditionalRenderingEXT + VkCommandBuffer commandBuffer + + + void vkCmdResetQueryPool + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + + + void vkCmdWriteTimestamp + VkCommandBuffer commandBuffer + VkPipelineStageFlagBits pipelineStage + VkQueryPool queryPool + uint32_t query + + + void vkCmdCopyQueryPoolResults + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize stride + VkQueryResultFlags flags + + + void vkCmdPushConstants + VkCommandBuffer commandBuffer + VkPipelineLayout layout + VkShaderStageFlags stageFlags + uint32_t offset + uint32_t size + const void* pValues + + + void vkCmdBeginRenderPass + VkCommandBuffer commandBuffer + const VkRenderPassBeginInfo* pRenderPassBegin + VkSubpassContents contents + + + void vkCmdNextSubpass + VkCommandBuffer commandBuffer + VkSubpassContents contents + + + void vkCmdEndRenderPass + VkCommandBuffer commandBuffer + + + void vkCmdExecuteCommands + VkCommandBuffer commandBuffer + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + + + VkResult vkCreateAndroidSurfaceKHR + VkInstance instance + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkGetPhysicalDeviceDisplayPropertiesKHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPropertiesKHR* pProperties + + + VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPlanePropertiesKHR* pProperties + + + VkResult vkGetDisplayPlaneSupportedDisplaysKHR + VkPhysicalDevice physicalDevice + uint32_t planeIndex + uint32_t* pDisplayCount + VkDisplayKHR* pDisplays + + + VkResult vkGetDisplayModePropertiesKHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + uint32_t* pPropertyCount + VkDisplayModePropertiesKHR* pProperties + + + VkResult vkCreateDisplayModeKHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + const VkDisplayModeCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDisplayModeKHR* pMode + + + VkResult vkGetDisplayPlaneCapabilitiesKHR + VkPhysicalDevice physicalDevice + VkDisplayModeKHR mode + uint32_t planeIndex + VkDisplayPlaneCapabilitiesKHR* pCapabilities + + + VkResult vkCreateDisplayPlaneSurfaceKHR + VkInstance instance + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateSharedSwapchainsKHR + VkDevice device + uint32_t swapchainCount + const VkSwapchainCreateInfoKHR* pCreateInfos + const VkSwapchainCreateInfoKHR* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkSwapchainKHR* pSwapchains + + + void vkDestroySurfaceKHR + VkInstance instance + VkSurfaceKHR surface + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetPhysicalDeviceSurfaceSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + VkSurfaceKHR surface + VkBool32* pSupported + + + VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities + + + VkResult vkGetPhysicalDeviceSurfaceFormatsKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pSurfaceFormatCount + VkSurfaceFormatKHR* pSurfaceFormats + + + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pPresentModeCount + VkPresentModeKHR* pPresentModes + + + VkResult vkCreateSwapchainKHR + VkDevice device + const VkSwapchainCreateInfoKHR* pCreateInfo + const VkSwapchainCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSwapchainKHR* pSwapchain + + + void vkDestroySwapchainKHR + VkDevice device + VkSwapchainKHR swapchain + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetSwapchainImagesKHR + VkDevice device + VkSwapchainKHR swapchain + uint32_t* pSwapchainImageCount + VkImage* pSwapchainImages + + + VkResult vkAcquireNextImageKHR + VkDevice device + VkSwapchainKHR swapchain + uint64_t timeout + VkSemaphore semaphore + VkFence fence + uint32_t* pImageIndex + + + VkResult vkQueuePresentKHR + VkQueue queue + const VkPresentInfoKHR* pPresentInfo + + + VkResult vkCreateViSurfaceNN + VkInstance instance + const VkViSurfaceCreateInfoNN* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateWaylandSurfaceKHR + VkInstance instance + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + struct wl_display* display + + + VkResult vkCreateWin32SurfaceKHR + VkInstance instance + const VkWin32SurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + + + VkResult vkCreateXlibSurfaceKHR + VkInstance instance + const VkXlibSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + Display* dpy + VisualID visualID + + + VkResult vkCreateXcbSurfaceKHR + VkInstance instance + const VkXcbSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + xcb_connection_t* connection + xcb_visualid_t visual_id + + + VkResult vkCreateDirectFBSurfaceEXT + VkInstance instance + const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + IDirectFB* dfb + + + VkResult vkCreateImagePipeSurfaceFUCHSIA + VkInstance instance + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateStreamDescriptorSurfaceGGP + VkInstance instance + const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateScreenSurfaceQNX + VkInstance instance + const VkScreenSurfaceCreateInfoQNX* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + struct _screen_window* window + + + VkResult vkCreateDebugReportCallbackEXT + VkInstance instance + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDebugReportCallbackEXT* pCallback + + + void vkDestroyDebugReportCallbackEXT + VkInstance instance + VkDebugReportCallbackEXT callback + const VkAllocationCallbacks* pAllocator + + + void vkDebugReportMessageEXT + VkInstance instance + VkDebugReportFlagsEXT flags + VkDebugReportObjectTypeEXT objectType + uint64_t object + size_t location + int32_t messageCode + const char* pLayerPrefix + const char* pMessage + + + VkResult vkDebugMarkerSetObjectNameEXT + VkDevice device + const VkDebugMarkerObjectNameInfoEXT* pNameInfo + + + VkResult vkDebugMarkerSetObjectTagEXT + VkDevice device + const VkDebugMarkerObjectTagInfoEXT* pTagInfo + + + void vkCmdDebugMarkerBeginEXT + VkCommandBuffer commandBuffer + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo + + + void vkCmdDebugMarkerEndEXT + VkCommandBuffer commandBuffer + + + void vkCmdDebugMarkerInsertEXT + VkCommandBuffer commandBuffer + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo + + + VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + VkExternalMemoryHandleTypeFlagsNV externalHandleType + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties + + + VkResult vkGetMemoryWin32HandleNV + VkDevice device + VkDeviceMemory memory + VkExternalMemoryHandleTypeFlagsNV handleType + HANDLE* pHandle + + + void vkCmdExecuteGeneratedCommandsNV + VkCommandBuffer commandBuffer + VkBool32 isPreprocessed + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo + + + void vkCmdPreprocessGeneratedCommandsNV + VkCommandBuffer commandBuffer + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo + + + void vkCmdBindPipelineShaderGroupNV + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipeline pipeline + uint32_t groupIndex + + + void vkGetGeneratedCommandsMemoryRequirementsNV + VkDevice device + const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + VkResult vkCreateIndirectCommandsLayoutNV + VkDevice device + const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkIndirectCommandsLayoutNV* pIndirectCommandsLayout + + + void vkDestroyIndirectCommandsLayoutNV + VkDevice device + VkIndirectCommandsLayoutNV indirectCommandsLayout + const VkAllocationCallbacks* pAllocator + + + void vkGetPhysicalDeviceFeatures2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceFeatures2* pFeatures + + + + void vkGetPhysicalDeviceProperties2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceProperties2* pProperties + + + + void vkGetPhysicalDeviceFormatProperties2 + VkPhysicalDevice physicalDevice + VkFormat format + VkFormatProperties2* pFormatProperties + + + + VkResult vkGetPhysicalDeviceImageFormatProperties2 + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo + VkImageFormatProperties2* pImageFormatProperties + + + + void vkGetPhysicalDeviceQueueFamilyProperties2 + VkPhysicalDevice physicalDevice + uint32_t* pQueueFamilyPropertyCount + VkQueueFamilyProperties2* pQueueFamilyProperties + + + + void vkGetPhysicalDeviceMemoryProperties2 + VkPhysicalDevice physicalDevice + VkPhysicalDeviceMemoryProperties2* pMemoryProperties + + + + void vkGetPhysicalDeviceSparseImageFormatProperties2 + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo + uint32_t* pPropertyCount + VkSparseImageFormatProperties2* pProperties + + + + void vkCmdPushDescriptorSetKHR + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout layout + uint32_t set + uint32_t descriptorWriteCount + const VkWriteDescriptorSet* pDescriptorWrites + + + void vkTrimCommandPool + VkDevice device + VkCommandPool commandPool + VkCommandPoolTrimFlags flags + + + + void vkGetPhysicalDeviceExternalBufferProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo + VkExternalBufferProperties* pExternalBufferProperties + + + + VkResult vkGetMemoryWin32HandleKHR + VkDevice device + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkGetMemoryWin32HandlePropertiesKHR + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + HANDLE handle + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties + + + VkResult vkGetMemoryFdKHR + VkDevice device + const VkMemoryGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkGetMemoryFdPropertiesKHR + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + int fd + VkMemoryFdPropertiesKHR* pMemoryFdProperties + + + VkResult vkGetMemoryZirconHandleFUCHSIA + VkDevice device + const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo + zx_handle_t* pZirconHandle + + + VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + zx_handle_t zirconHandle + VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties + + + VkResult vkGetMemoryRemoteAddressNV + VkDevice device + const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo + VkRemoteAddressNV* pAddress + + + VkResult vkGetMemorySciBufNV + VkDevice device + const VkMemoryGetSciBufInfoNV* pGetSciBufInfo + NvSciBufObj* pHandle + + + VkResult vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV + VkPhysicalDevice physicalDevice + VkExternalMemoryHandleTypeFlagBits handleType + NvSciBufObj handle + VkMemorySciBufPropertiesNV* pMemorySciBufProperties + + + VkResult vkGetPhysicalDeviceSciBufAttributesNV + VkPhysicalDevice physicalDevice + NvSciBufAttrList pAttributes + + + void vkGetPhysicalDeviceExternalSemaphoreProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo + VkExternalSemaphoreProperties* pExternalSemaphoreProperties + + + + VkResult vkGetSemaphoreWin32HandleKHR + VkDevice device + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkImportSemaphoreWin32HandleKHR + VkDevice device + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo + + + VkResult vkGetSemaphoreFdKHR + VkDevice device + const VkSemaphoreGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkImportSemaphoreFdKHR + VkDevice device + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo + + + VkResult vkGetSemaphoreZirconHandleFUCHSIA + VkDevice device + const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo + zx_handle_t* pZirconHandle + + + VkResult vkImportSemaphoreZirconHandleFUCHSIA + VkDevice device + const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo + + + void vkGetPhysicalDeviceExternalFenceProperties + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo + VkExternalFenceProperties* pExternalFenceProperties + + + + VkResult vkGetFenceWin32HandleKHR + VkDevice device + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo + HANDLE* pHandle + + + VkResult vkImportFenceWin32HandleKHR + VkDevice device + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo + + + VkResult vkGetFenceFdKHR + VkDevice device + const VkFenceGetFdInfoKHR* pGetFdInfo + int* pFd + + + VkResult vkImportFenceFdKHR + VkDevice device + const VkImportFenceFdInfoKHR* pImportFenceFdInfo + + + VkResult vkGetFenceSciSyncFenceNV + VkDevice device + const VkFenceGetSciSyncInfoNV* pGetSciSyncHandleInfo + void* pHandle + + + VkResult vkGetFenceSciSyncObjNV + VkDevice device + const VkFenceGetSciSyncInfoNV* pGetSciSyncHandleInfo + void* pHandle + + + VkResult vkImportFenceSciSyncFenceNV + VkDevice device + const VkImportFenceSciSyncInfoNV* pImportFenceSciSyncInfo + + + VkResult vkImportFenceSciSyncObjNV + VkDevice device + const VkImportFenceSciSyncInfoNV* pImportFenceSciSyncInfo + + + VkResult vkGetSemaphoreSciSyncObjNV + VkDevice device + const VkSemaphoreGetSciSyncInfoNV* pGetSciSyncInfo + void* pHandle + + + VkResult vkImportSemaphoreSciSyncObjNV + VkDevice device + const VkImportSemaphoreSciSyncInfoNV* pImportSemaphoreSciSyncInfo + + + VkResult vkGetPhysicalDeviceSciSyncAttributesNV + VkPhysicalDevice physicalDevice + const VkSciSyncAttributesInfoNV* pSciSyncAttributesInfo + NvSciSyncAttrList pAttributes + + + VkResult vkCreateSemaphoreSciSyncPoolNV + VkDevice device + const VkSemaphoreSciSyncPoolCreateInfoNV* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSemaphoreSciSyncPoolNV* pSemaphorePool + + + void vkDestroySemaphoreSciSyncPoolNV + VkDevice device + VkSemaphoreSciSyncPoolNV semaphorePool + const VkAllocationCallbacks* pAllocator + + + VkResult vkReleaseDisplayEXT + VkPhysicalDevice physicalDevice + VkDisplayKHR display + + + VkResult vkAcquireXlibDisplayEXT + VkPhysicalDevice physicalDevice + Display* dpy + VkDisplayKHR display + + + VkResult vkGetRandROutputDisplayEXT + VkPhysicalDevice physicalDevice + Display* dpy + RROutput rrOutput + VkDisplayKHR* pDisplay + + + VkResult vkAcquireWinrtDisplayNV + VkPhysicalDevice physicalDevice + VkDisplayKHR display + + + VkResult vkGetWinrtDisplayNV + VkPhysicalDevice physicalDevice + uint32_t deviceRelativeId + VkDisplayKHR* pDisplay + + + VkResult vkDisplayPowerControlEXT + VkDevice device + VkDisplayKHR display + const VkDisplayPowerInfoEXT* pDisplayPowerInfo + + + VkResult vkRegisterDeviceEventEXT + VkDevice device + const VkDeviceEventInfoEXT* pDeviceEventInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + VkResult vkRegisterDisplayEventEXT + VkDevice device + VkDisplayKHR display + const VkDisplayEventInfoEXT* pDisplayEventInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + VkResult vkGetSwapchainCounterEXT + VkDevice device + VkSwapchainKHR swapchain + VkSurfaceCounterFlagBitsEXT counter + uint64_t* pCounterValue + + + VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + VkSurfaceCapabilities2EXT* pSurfaceCapabilities + + + VkResult vkEnumeratePhysicalDeviceGroups + VkInstance instance + uint32_t* pPhysicalDeviceGroupCount + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties + + + + void vkGetDeviceGroupPeerMemoryFeatures + VkDevice device + uint32_t heapIndex + uint32_t localDeviceIndex + uint32_t remoteDeviceIndex + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures + + + + VkResult vkBindBufferMemory2 + VkDevice device + uint32_t bindInfoCount + const VkBindBufferMemoryInfo* pBindInfos + + + + VkResult vkBindImageMemory2 + VkDevice device + uint32_t bindInfoCount + const VkBindImageMemoryInfo* pBindInfos + + + + void vkCmdSetDeviceMask + VkCommandBuffer commandBuffer + uint32_t deviceMask + + + + VkResult vkGetDeviceGroupPresentCapabilitiesKHR + VkDevice device + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities + + + VkResult vkGetDeviceGroupSurfacePresentModesKHR + VkDevice device + VkSurfaceKHR surface + VkDeviceGroupPresentModeFlagsKHR* pModes + + + VkResult vkAcquireNextImage2KHR + VkDevice device + const VkAcquireNextImageInfoKHR* pAcquireInfo + uint32_t* pImageIndex + + + void vkCmdDispatchBase + VkCommandBuffer commandBuffer + uint32_t baseGroupX + uint32_t baseGroupY + uint32_t baseGroupZ + uint32_t groupCountX + uint32_t groupCountY + uint32_t groupCountZ + + + + VkResult vkGetPhysicalDevicePresentRectanglesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pRectCount + VkRect2D* pRects + + + VkResult vkCreateDescriptorUpdateTemplate + VkDevice device + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate + + + + void vkDestroyDescriptorUpdateTemplate + VkDevice device + VkDescriptorUpdateTemplate descriptorUpdateTemplate + const VkAllocationCallbacks* pAllocator + + + + void vkUpdateDescriptorSetWithTemplate + VkDevice device + VkDescriptorSet descriptorSet + VkDescriptorUpdateTemplate descriptorUpdateTemplate + const void* pData + + + + void vkCmdPushDescriptorSetWithTemplateKHR + VkCommandBuffer commandBuffer + VkDescriptorUpdateTemplate descriptorUpdateTemplate + VkPipelineLayout layout + uint32_t set + const void* pData + + + void vkSetHdrMetadataEXT + VkDevice device + uint32_t swapchainCount + const VkSwapchainKHR* pSwapchains + const VkHdrMetadataEXT* pMetadata + + + VkResult vkGetSwapchainStatusKHR + VkDevice device + VkSwapchainKHR swapchain + + + VkResult vkGetRefreshCycleDurationGOOGLE + VkDevice device + VkSwapchainKHR swapchain + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties + + + VkResult vkGetPastPresentationTimingGOOGLE + VkDevice device + VkSwapchainKHR swapchain + uint32_t* pPresentationTimingCount + VkPastPresentationTimingGOOGLE* pPresentationTimings + + + VkResult vkCreateIOSSurfaceMVK + VkInstance instance + const VkIOSSurfaceCreateInfoMVK* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateMacOSSurfaceMVK + VkInstance instance + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateMetalSurfaceEXT + VkInstance instance + const VkMetalSurfaceCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + void vkCmdSetViewportWScalingNV + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkViewportWScalingNV* pViewportWScalings + + + void vkCmdSetDiscardRectangleEXT + VkCommandBuffer commandBuffer + uint32_t firstDiscardRectangle + uint32_t discardRectangleCount + const VkRect2D* pDiscardRectangles + + + void vkCmdSetDiscardRectangleEnableEXT + VkCommandBuffer commandBuffer + VkBool32 discardRectangleEnable + + + void vkCmdSetDiscardRectangleModeEXT + VkCommandBuffer commandBuffer + VkDiscardRectangleModeEXT discardRectangleMode + + + void vkCmdSetSampleLocationsEXT + VkCommandBuffer commandBuffer + const VkSampleLocationsInfoEXT* pSampleLocationsInfo + + + void vkGetPhysicalDeviceMultisamplePropertiesEXT + VkPhysicalDevice physicalDevice + VkSampleCountFlagBits samples + VkMultisamplePropertiesEXT* pMultisampleProperties + + + VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + VkSurfaceCapabilities2KHR* pSurfaceCapabilities + + + VkResult vkGetPhysicalDeviceSurfaceFormats2KHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + uint32_t* pSurfaceFormatCount + VkSurfaceFormat2KHR* pSurfaceFormats + + + VkResult vkGetPhysicalDeviceDisplayProperties2KHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayProperties2KHR* pProperties + + + VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPlaneProperties2KHR* pProperties + + + VkResult vkGetDisplayModeProperties2KHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + uint32_t* pPropertyCount + VkDisplayModeProperties2KHR* pProperties + + + VkResult vkGetDisplayPlaneCapabilities2KHR + VkPhysicalDevice physicalDevice + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo + VkDisplayPlaneCapabilities2KHR* pCapabilities + + + void vkGetBufferMemoryRequirements2 + VkDevice device + const VkBufferMemoryRequirementsInfo2* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + + void vkGetImageMemoryRequirements2 + VkDevice device + const VkImageMemoryRequirementsInfo2* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + + void vkGetImageSparseMemoryRequirements2 + VkDevice device + const VkImageSparseMemoryRequirementsInfo2* pInfo + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements + + + + void vkGetDeviceBufferMemoryRequirements + VkDevice device + const VkDeviceBufferMemoryRequirements* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + + void vkGetDeviceImageMemoryRequirements + VkDevice device + const VkDeviceImageMemoryRequirements* pInfo + VkMemoryRequirements2* pMemoryRequirements + + + + void vkGetDeviceImageSparseMemoryRequirements + VkDevice device + const VkDeviceImageMemoryRequirements* pInfo + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements + + + + VkResult vkCreateSamplerYcbcrConversion + VkDevice device + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSamplerYcbcrConversion* pYcbcrConversion + + + + void vkDestroySamplerYcbcrConversion + VkDevice device + VkSamplerYcbcrConversion ycbcrConversion + const VkAllocationCallbacks* pAllocator + + + + void vkGetDeviceQueue2 + VkDevice device + const VkDeviceQueueInfo2* pQueueInfo + VkQueue* pQueue + + + VkResult vkCreateValidationCacheEXT + VkDevice device + const VkValidationCacheCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkValidationCacheEXT* pValidationCache + + + void vkDestroyValidationCacheEXT + VkDevice device + VkValidationCacheEXT validationCache + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetValidationCacheDataEXT + VkDevice device + VkValidationCacheEXT validationCache + size_t* pDataSize + void* pData + + + VkResult vkMergeValidationCachesEXT + VkDevice device + VkValidationCacheEXT dstCache + uint32_t srcCacheCount + const VkValidationCacheEXT* pSrcCaches + + + void vkGetDescriptorSetLayoutSupport + VkDevice device + const VkDescriptorSetLayoutCreateInfo* pCreateInfo + VkDescriptorSetLayoutSupport* pSupport + + + + VkResult vkGetSwapchainGrallocUsageANDROID + VkDevice device + VkFormat format + VkImageUsageFlags imageUsage + int* grallocUsage + + + VkResult vkGetSwapchainGrallocUsage2ANDROID + VkDevice device + VkFormat format + VkImageUsageFlags imageUsage + VkSwapchainImageUsageFlagsANDROID swapchainImageUsage + uint64_t* grallocConsumerUsage + uint64_t* grallocProducerUsage + + + VkResult vkAcquireImageANDROID + VkDevice device + VkImage image + int nativeFenceFd + VkSemaphore semaphore + VkFence fence + + + VkResult vkQueueSignalReleaseImageANDROID + VkQueue queue + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + VkImage image + int* pNativeFenceFd + + + VkResult vkGetShaderInfoAMD + VkDevice device + VkPipeline pipeline + VkShaderStageFlagBits shaderStage + VkShaderInfoTypeAMD infoType + size_t* pInfoSize + void* pInfo + + + void vkSetLocalDimmingAMD + VkDevice device + VkSwapchainKHR swapChain + VkBool32 localDimmingEnable + + + VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT + VkPhysicalDevice physicalDevice + uint32_t* pTimeDomainCount + VkTimeDomainEXT* pTimeDomains + + + VkResult vkGetCalibratedTimestampsEXT + VkDevice device + uint32_t timestampCount + const VkCalibratedTimestampInfoEXT* pTimestampInfos + uint64_t* pTimestamps + uint64_t* pMaxDeviation + + + VkResult vkSetDebugUtilsObjectNameEXT + VkDevice device + const VkDebugUtilsObjectNameInfoEXT* pNameInfo + + + VkResult vkSetDebugUtilsObjectTagEXT + VkDevice device + const VkDebugUtilsObjectTagInfoEXT* pTagInfo + + + void vkQueueBeginDebugUtilsLabelEXT + VkQueue queue + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkQueueEndDebugUtilsLabelEXT + VkQueue queue + + + void vkQueueInsertDebugUtilsLabelEXT + VkQueue queue + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkCmdBeginDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + const VkDebugUtilsLabelEXT* pLabelInfo + + + void vkCmdEndDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + + + void vkCmdInsertDebugUtilsLabelEXT + VkCommandBuffer commandBuffer + const VkDebugUtilsLabelEXT* pLabelInfo + + + VkResult vkCreateDebugUtilsMessengerEXT + VkInstance instance + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDebugUtilsMessengerEXT* pMessenger + + + void vkDestroyDebugUtilsMessengerEXT + VkInstance instance + VkDebugUtilsMessengerEXT messenger + const VkAllocationCallbacks* pAllocator + + + void vkSubmitDebugUtilsMessageEXT + VkInstance instance + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity + VkDebugUtilsMessageTypeFlagsEXT messageTypes + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData + + + VkResult vkGetMemoryHostPointerPropertiesEXT + VkDevice device + VkExternalMemoryHandleTypeFlagBits handleType + const void* pHostPointer + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties + + + void vkCmdWriteBufferMarkerAMD + VkCommandBuffer commandBuffer + VkPipelineStageFlagBits pipelineStage + VkBuffer dstBuffer + VkDeviceSize dstOffset + uint32_t marker + + + VkResult vkCreateRenderPass2 + VkDevice device + const VkRenderPassCreateInfo2* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkRenderPass* pRenderPass + + + + void vkCmdBeginRenderPass2 + VkCommandBuffer commandBuffer + const VkRenderPassBeginInfo* pRenderPassBegin + const VkSubpassBeginInfo* pSubpassBeginInfo + + + + void vkCmdNextSubpass2 + VkCommandBuffer commandBuffer + const VkSubpassBeginInfo* pSubpassBeginInfo + const VkSubpassEndInfo* pSubpassEndInfo + + + + void vkCmdEndRenderPass2 + VkCommandBuffer commandBuffer + const VkSubpassEndInfo* pSubpassEndInfo + + + + VkResult vkGetSemaphoreCounterValue + VkDevice device + VkSemaphore semaphore + uint64_t* pValue + + + + VkResult vkWaitSemaphores + VkDevice device + const VkSemaphoreWaitInfo* pWaitInfo + uint64_t timeout + + + + VkResult vkSignalSemaphore + VkDevice device + const VkSemaphoreSignalInfo* pSignalInfo + + + + VkResult vkGetAndroidHardwareBufferPropertiesANDROID + VkDevice device + const struct AHardwareBuffer* buffer + VkAndroidHardwareBufferPropertiesANDROID* pProperties + + + VkResult vkGetMemoryAndroidHardwareBufferANDROID + VkDevice device + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo + struct AHardwareBuffer** pBuffer + + + void vkCmdDrawIndirectCount + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + + + void vkCmdDrawIndexedIndirectCount + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + + + void vkCmdSetCheckpointNV + VkCommandBuffer commandBuffer + const void* pCheckpointMarker + + + void vkGetQueueCheckpointDataNV + VkQueue queue + uint32_t* pCheckpointDataCount + VkCheckpointDataNV* pCheckpointData + + + void vkCmdBindTransformFeedbackBuffersEXT + VkCommandBuffer commandBuffer + uint32_t firstBinding + uint32_t bindingCount + const VkBuffer* pBuffers + const VkDeviceSize* pOffsets + const VkDeviceSize* pSizes + + + void vkCmdBeginTransformFeedbackEXT + VkCommandBuffer commandBuffer + uint32_t firstCounterBuffer + uint32_t counterBufferCount + const VkBuffer* pCounterBuffers + const VkDeviceSize* pCounterBufferOffsets + + + void vkCmdEndTransformFeedbackEXT + VkCommandBuffer commandBuffer + uint32_t firstCounterBuffer + uint32_t counterBufferCount + const VkBuffer* pCounterBuffers + const VkDeviceSize* pCounterBufferOffsets + + + void vkCmdBeginQueryIndexedEXT + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + VkQueryControlFlags flags + uint32_t index + + + void vkCmdEndQueryIndexedEXT + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + uint32_t index + + + void vkCmdDrawIndirectByteCountEXT + VkCommandBuffer commandBuffer + uint32_t instanceCount + uint32_t firstInstance + VkBuffer counterBuffer + VkDeviceSize counterBufferOffset + uint32_t counterOffset + uint32_t vertexStride + + + void vkCmdSetExclusiveScissorNV + VkCommandBuffer commandBuffer + uint32_t firstExclusiveScissor + uint32_t exclusiveScissorCount + const VkRect2D* pExclusiveScissors + + + void vkCmdSetExclusiveScissorEnableNV + VkCommandBuffer commandBuffer + uint32_t firstExclusiveScissor + uint32_t exclusiveScissorCount + const VkBool32* pExclusiveScissorEnables + + + void vkCmdBindShadingRateImageNV + VkCommandBuffer commandBuffer + VkImageView imageView + VkImageLayout imageLayout + + + void vkCmdSetViewportShadingRatePaletteNV + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkShadingRatePaletteNV* pShadingRatePalettes + + + void vkCmdSetCoarseSampleOrderNV + VkCommandBuffer commandBuffer + VkCoarseSampleOrderTypeNV sampleOrderType + uint32_t customSampleOrderCount + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders + + + void vkCmdDrawMeshTasksNV + VkCommandBuffer commandBuffer + uint32_t taskCount + uint32_t firstTask + + + void vkCmdDrawMeshTasksIndirectNV + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + + void vkCmdDrawMeshTasksIndirectCountNV + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + void vkCmdDrawMeshTasksEXT + VkCommandBuffer commandBuffer + uint32_t groupCountX + uint32_t groupCountY + uint32_t groupCountZ + + + void vkCmdDrawMeshTasksIndirectEXT + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + + void vkCmdDrawMeshTasksIndirectCountEXT + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkBuffer countBuffer + VkDeviceSize countBufferOffset + uint32_t maxDrawCount + uint32_t stride + + + VkResult vkCompileDeferredNV + VkDevice device + VkPipeline pipeline + uint32_t shader + + + VkResult vkCreateAccelerationStructureNV + VkDevice device + const VkAccelerationStructureCreateInfoNV* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkAccelerationStructureNV* pAccelerationStructure + + + void vkCmdBindInvocationMaskHUAWEI + VkCommandBuffer commandBuffer + VkImageView imageView + VkImageLayout imageLayout + + + void vkDestroyAccelerationStructureKHR + VkDevice device + VkAccelerationStructureKHR accelerationStructure + const VkAllocationCallbacks* pAllocator + + + void vkDestroyAccelerationStructureNV + VkDevice device + VkAccelerationStructureNV accelerationStructure + const VkAllocationCallbacks* pAllocator + + + void vkGetAccelerationStructureMemoryRequirementsNV + VkDevice device + const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo + VkMemoryRequirements2KHR* pMemoryRequirements + + + VkResult vkBindAccelerationStructureMemoryNV + VkDevice device + uint32_t bindInfoCount + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos + + + void vkCmdCopyAccelerationStructureNV + VkCommandBuffer commandBuffer + VkAccelerationStructureNV dst + VkAccelerationStructureNV src + VkCopyAccelerationStructureModeKHR mode + + + void vkCmdCopyAccelerationStructureKHR + VkCommandBuffer commandBuffer + const VkCopyAccelerationStructureInfoKHR* pInfo + + + VkResult vkCopyAccelerationStructureKHR + VkDevice device + VkDeferredOperationKHR deferredOperation + const VkCopyAccelerationStructureInfoKHR* pInfo + + + void vkCmdCopyAccelerationStructureToMemoryKHR + VkCommandBuffer commandBuffer + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo + + + VkResult vkCopyAccelerationStructureToMemoryKHR + VkDevice device + VkDeferredOperationKHR deferredOperation + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo + + + void vkCmdCopyMemoryToAccelerationStructureKHR + VkCommandBuffer commandBuffer + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo + + + VkResult vkCopyMemoryToAccelerationStructureKHR + VkDevice device + VkDeferredOperationKHR deferredOperation + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo + + + void vkCmdWriteAccelerationStructuresPropertiesKHR + VkCommandBuffer commandBuffer + uint32_t accelerationStructureCount + const VkAccelerationStructureKHR* pAccelerationStructures + VkQueryType queryType + VkQueryPool queryPool + uint32_t firstQuery + + + void vkCmdWriteAccelerationStructuresPropertiesNV + VkCommandBuffer commandBuffer + uint32_t accelerationStructureCount + const VkAccelerationStructureNV* pAccelerationStructures + VkQueryType queryType + VkQueryPool queryPool + uint32_t firstQuery + + + void vkCmdBuildAccelerationStructureNV + VkCommandBuffer commandBuffer + const VkAccelerationStructureInfoNV* pInfo + VkBuffer instanceData + VkDeviceSize instanceOffset + VkBool32 update + VkAccelerationStructureNV dst + VkAccelerationStructureNV src + VkBuffer scratch + VkDeviceSize scratchOffset + + + VkResult vkWriteAccelerationStructuresPropertiesKHR + VkDevice device + uint32_t accelerationStructureCount + const VkAccelerationStructureKHR* pAccelerationStructures + VkQueryType queryType + size_t dataSize + void* pData + size_t stride + + + void vkCmdTraceRaysKHR + VkCommandBuffer commandBuffer + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable + uint32_t width + uint32_t height + uint32_t depth + + + void vkCmdTraceRaysNV + VkCommandBuffer commandBuffer + VkBuffer raygenShaderBindingTableBuffer + VkDeviceSize raygenShaderBindingOffset + VkBuffer missShaderBindingTableBuffer + VkDeviceSize missShaderBindingOffset + VkDeviceSize missShaderBindingStride + VkBuffer hitShaderBindingTableBuffer + VkDeviceSize hitShaderBindingOffset + VkDeviceSize hitShaderBindingStride + VkBuffer callableShaderBindingTableBuffer + VkDeviceSize callableShaderBindingOffset + VkDeviceSize callableShaderBindingStride + uint32_t width + uint32_t height + uint32_t depth + + + VkResult vkGetRayTracingShaderGroupHandlesKHR + VkDevice device + VkPipeline pipeline + uint32_t firstGroup + uint32_t groupCount + size_t dataSize + void* pData + + + + VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR + VkDevice device + VkPipeline pipeline + uint32_t firstGroup + uint32_t groupCount + size_t dataSize + void* pData + + + VkResult vkGetAccelerationStructureHandleNV + VkDevice device + VkAccelerationStructureNV accelerationStructure + size_t dataSize + void* pData + + + VkResult vkCreateRayTracingPipelinesNV + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkRayTracingPipelineCreateInfoNV* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkCreateRayTracingPipelinesNV + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkRayTracingPipelineCreateInfoNV* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkCreateRayTracingPipelinesKHR + VkDevice device + VkDeferredOperationKHR deferredOperation + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkCreateRayTracingPipelinesKHR + VkDevice device + VkDeferredOperationKHR deferredOperation + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + + VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkCooperativeMatrixPropertiesNV* pProperties + + + void vkCmdTraceRaysIndirectKHR + VkCommandBuffer commandBuffer + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable + VkDeviceAddress indirectDeviceAddress + + + void vkCmdTraceRaysIndirect2KHR + VkCommandBuffer commandBuffer + VkDeviceAddress indirectDeviceAddress + + + void vkGetDeviceAccelerationStructureCompatibilityKHR + VkDevice device + const VkAccelerationStructureVersionInfoKHR* pVersionInfo + VkAccelerationStructureCompatibilityKHR* pCompatibility + + + VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR + VkDevice device + VkPipeline pipeline + uint32_t group + VkShaderGroupShaderKHR groupShader + + + void vkCmdSetRayTracingPipelineStackSizeKHR + VkCommandBuffer commandBuffer + uint32_t pipelineStackSize + + + uint32_t vkGetImageViewHandleNVX + VkDevice device + const VkImageViewHandleInfoNVX* pInfo + + + VkResult vkGetImageViewAddressNVX + VkDevice device + VkImageView imageView + VkImageViewAddressPropertiesNVX* pProperties + + + VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + uint32_t* pPresentModeCount + VkPresentModeKHR* pPresentModes + + + VkResult vkGetDeviceGroupSurfacePresentModes2EXT + VkDevice device + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo + VkDeviceGroupPresentModeFlagsKHR* pModes + + + VkResult vkAcquireFullScreenExclusiveModeEXT + VkDevice device + VkSwapchainKHR swapchain + + + VkResult vkReleaseFullScreenExclusiveModeEXT + VkDevice device + VkSwapchainKHR swapchain + + + VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + uint32_t* pCounterCount + VkPerformanceCounterKHR* pCounters + VkPerformanceCounterDescriptionKHR* pCounterDescriptions + + + void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR + VkPhysicalDevice physicalDevice + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo + uint32_t* pNumPasses + + + VkResult vkAcquireProfilingLockKHR + VkDevice device + const VkAcquireProfilingLockInfoKHR* pInfo + + + void vkReleaseProfilingLockKHR + VkDevice device + + + VkResult vkGetImageDrmFormatModifierPropertiesEXT + VkDevice device + VkImage image + VkImageDrmFormatModifierPropertiesEXT* pProperties + + + uint64_t vkGetBufferOpaqueCaptureAddress + VkDevice device + const VkBufferDeviceAddressInfo* pInfo + + + + VkDeviceAddress vkGetBufferDeviceAddress + VkDevice device + const VkBufferDeviceAddressInfo* pInfo + + + + + VkResult vkCreateHeadlessSurfaceEXT + VkInstance instance + const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV + VkPhysicalDevice physicalDevice + uint32_t* pCombinationCount + VkFramebufferMixedSamplesCombinationNV* pCombinations + + + VkResult vkInitializePerformanceApiINTEL + VkDevice device + const VkInitializePerformanceApiInfoINTEL* pInitializeInfo + + + void vkUninitializePerformanceApiINTEL + VkDevice device + + + VkResult vkCmdSetPerformanceMarkerINTEL + VkCommandBuffer commandBuffer + const VkPerformanceMarkerInfoINTEL* pMarkerInfo + + + VkResult vkCmdSetPerformanceStreamMarkerINTEL + VkCommandBuffer commandBuffer + const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo + + + VkResult vkCmdSetPerformanceOverrideINTEL + VkCommandBuffer commandBuffer + const VkPerformanceOverrideInfoINTEL* pOverrideInfo + + + VkResult vkAcquirePerformanceConfigurationINTEL + VkDevice device + const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo + VkPerformanceConfigurationINTEL* pConfiguration + + + VkResult vkReleasePerformanceConfigurationINTEL + VkDevice device + VkPerformanceConfigurationINTEL configuration + + + VkResult vkQueueSetPerformanceConfigurationINTEL + VkQueue queue + VkPerformanceConfigurationINTEL configuration + + + VkResult vkGetPerformanceParameterINTEL + VkDevice device + VkPerformanceParameterTypeINTEL parameter + VkPerformanceValueINTEL* pValue + + + uint64_t vkGetDeviceMemoryOpaqueCaptureAddress + VkDevice device + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo + + + + VkResult vkGetPipelineExecutablePropertiesKHR + VkDevice device + const VkPipelineInfoKHR* pPipelineInfo + uint32_t* pExecutableCount + VkPipelineExecutablePropertiesKHR* pProperties + + + VkResult vkGetPipelineExecutableStatisticsKHR + VkDevice device + const VkPipelineExecutableInfoKHR* pExecutableInfo + uint32_t* pStatisticCount + VkPipelineExecutableStatisticKHR* pStatistics + + + VkResult vkGetPipelineExecutableInternalRepresentationsKHR + VkDevice device + const VkPipelineExecutableInfoKHR* pExecutableInfo + uint32_t* pInternalRepresentationCount + VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations + + + void vkCmdSetLineStippleEXT + VkCommandBuffer commandBuffer + uint32_t lineStippleFactor + uint16_t lineStipplePattern + + + VkResult vkGetFaultData + VkDevice device + VkFaultQueryBehavior faultQueryBehavior + VkBool32* pUnrecordedFaults + uint32_t* pFaultCount + VkFaultData* pFaults + + + VkResult vkGetPhysicalDeviceToolProperties + VkPhysicalDevice physicalDevice + uint32_t* pToolCount + VkPhysicalDeviceToolProperties* pToolProperties + + + + VkResult vkCreateAccelerationStructureKHR + VkDevice device + const VkAccelerationStructureCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkAccelerationStructureKHR* pAccelerationStructure + + + void vkCmdBuildAccelerationStructuresKHR + VkCommandBuffer commandBuffer + uint32_t infoCount + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos + + + void vkCmdBuildAccelerationStructuresIndirectKHR + VkCommandBuffer commandBuffer + uint32_t infoCount + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos + const VkDeviceAddress* pIndirectDeviceAddresses + const uint32_t* pIndirectStrides + const uint32_t* const* ppMaxPrimitiveCounts + + + VkResult vkBuildAccelerationStructuresKHR + VkDevice device + VkDeferredOperationKHR deferredOperation + uint32_t infoCount + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos + + + VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR + VkDevice device + const VkAccelerationStructureDeviceAddressInfoKHR* pInfo + + + VkResult vkCreateDeferredOperationKHR + VkDevice device + const VkAllocationCallbacks* pAllocator + VkDeferredOperationKHR* pDeferredOperation + + + void vkDestroyDeferredOperationKHR + VkDevice device + VkDeferredOperationKHR operation + const VkAllocationCallbacks* pAllocator + + + uint32_t vkGetDeferredOperationMaxConcurrencyKHR + VkDevice device + VkDeferredOperationKHR operation + + + VkResult vkGetDeferredOperationResultKHR + VkDevice device + VkDeferredOperationKHR operation + + + VkResult vkDeferredOperationJoinKHR + VkDevice device + VkDeferredOperationKHR operation + + + void vkCmdSetCullMode + VkCommandBuffer commandBuffer + VkCullModeFlags cullMode + + + + void vkCmdSetFrontFace + VkCommandBuffer commandBuffer + VkFrontFace frontFace + + + + void vkCmdSetPrimitiveTopology + VkCommandBuffer commandBuffer + VkPrimitiveTopology primitiveTopology + + + + void vkCmdSetViewportWithCount + VkCommandBuffer commandBuffer + uint32_t viewportCount + const VkViewport* pViewports + + + + void vkCmdSetScissorWithCount + VkCommandBuffer commandBuffer + uint32_t scissorCount + const VkRect2D* pScissors + + + + void vkCmdBindVertexBuffers2 + VkCommandBuffer commandBuffer + uint32_t firstBinding + uint32_t bindingCount + const VkBuffer* pBuffers + const VkDeviceSize* pOffsets + const VkDeviceSize* pSizes + const VkDeviceSize* pStrides + + + + void vkCmdSetDepthTestEnable + VkCommandBuffer commandBuffer + VkBool32 depthTestEnable + + + + void vkCmdSetDepthWriteEnable + VkCommandBuffer commandBuffer + VkBool32 depthWriteEnable + + + + void vkCmdSetDepthCompareOp + VkCommandBuffer commandBuffer + VkCompareOp depthCompareOp + + + + void vkCmdSetDepthBoundsTestEnable + VkCommandBuffer commandBuffer + VkBool32 depthBoundsTestEnable + + + + void vkCmdSetStencilTestEnable + VkCommandBuffer commandBuffer + VkBool32 stencilTestEnable + + + + void vkCmdSetStencilOp + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + VkStencilOp failOp + VkStencilOp passOp + VkStencilOp depthFailOp + VkCompareOp compareOp + + + + void vkCmdSetPatchControlPointsEXT + VkCommandBuffer commandBuffer + uint32_t patchControlPoints + + + void vkCmdSetRasterizerDiscardEnable + VkCommandBuffer commandBuffer + VkBool32 rasterizerDiscardEnable + + + + void vkCmdSetDepthBiasEnable + VkCommandBuffer commandBuffer + VkBool32 depthBiasEnable + + + + void vkCmdSetLogicOpEXT + VkCommandBuffer commandBuffer + VkLogicOp logicOp + + + void vkCmdSetPrimitiveRestartEnable + VkCommandBuffer commandBuffer + VkBool32 primitiveRestartEnable + + + + void vkCmdSetTessellationDomainOriginEXT + VkCommandBuffer commandBuffer + VkTessellationDomainOrigin domainOrigin + + + void vkCmdSetDepthClampEnableEXT + VkCommandBuffer commandBuffer + VkBool32 depthClampEnable + + + void vkCmdSetPolygonModeEXT + VkCommandBuffer commandBuffer + VkPolygonMode polygonMode + + + void vkCmdSetRasterizationSamplesEXT + VkCommandBuffer commandBuffer + VkSampleCountFlagBits rasterizationSamples + + + void vkCmdSetSampleMaskEXT + VkCommandBuffer commandBuffer + VkSampleCountFlagBits samples + const VkSampleMask* pSampleMask + + + void vkCmdSetAlphaToCoverageEnableEXT + VkCommandBuffer commandBuffer + VkBool32 alphaToCoverageEnable + + + void vkCmdSetAlphaToOneEnableEXT + VkCommandBuffer commandBuffer + VkBool32 alphaToOneEnable + + + void vkCmdSetLogicOpEnableEXT + VkCommandBuffer commandBuffer + VkBool32 logicOpEnable + + + void vkCmdSetColorBlendEnableEXT + VkCommandBuffer commandBuffer + uint32_t firstAttachment + uint32_t attachmentCount + const VkBool32* pColorBlendEnables + + + void vkCmdSetColorBlendEquationEXT + VkCommandBuffer commandBuffer + uint32_t firstAttachment + uint32_t attachmentCount + const VkColorBlendEquationEXT* pColorBlendEquations + + + void vkCmdSetColorWriteMaskEXT + VkCommandBuffer commandBuffer + uint32_t firstAttachment + uint32_t attachmentCount + const VkColorComponentFlags* pColorWriteMasks + + + void vkCmdSetRasterizationStreamEXT + VkCommandBuffer commandBuffer + uint32_t rasterizationStream + + + void vkCmdSetConservativeRasterizationModeEXT + VkCommandBuffer commandBuffer + VkConservativeRasterizationModeEXT conservativeRasterizationMode + + + void vkCmdSetExtraPrimitiveOverestimationSizeEXT + VkCommandBuffer commandBuffer + float extraPrimitiveOverestimationSize + + + void vkCmdSetDepthClipEnableEXT + VkCommandBuffer commandBuffer + VkBool32 depthClipEnable + + + void vkCmdSetSampleLocationsEnableEXT + VkCommandBuffer commandBuffer + VkBool32 sampleLocationsEnable + + + void vkCmdSetColorBlendAdvancedEXT + VkCommandBuffer commandBuffer + uint32_t firstAttachment + uint32_t attachmentCount + const VkColorBlendAdvancedEXT* pColorBlendAdvanced + + + void vkCmdSetProvokingVertexModeEXT + VkCommandBuffer commandBuffer + VkProvokingVertexModeEXT provokingVertexMode + + + void vkCmdSetLineRasterizationModeEXT + VkCommandBuffer commandBuffer + VkLineRasterizationModeEXT lineRasterizationMode + + + void vkCmdSetLineStippleEnableEXT + VkCommandBuffer commandBuffer + VkBool32 stippledLineEnable + + + void vkCmdSetDepthClipNegativeOneToOneEXT + VkCommandBuffer commandBuffer + VkBool32 negativeOneToOne + + + void vkCmdSetViewportWScalingEnableNV + VkCommandBuffer commandBuffer + VkBool32 viewportWScalingEnable + + + void vkCmdSetViewportSwizzleNV + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkViewportSwizzleNV* pViewportSwizzles + + + void vkCmdSetCoverageToColorEnableNV + VkCommandBuffer commandBuffer + VkBool32 coverageToColorEnable + + + void vkCmdSetCoverageToColorLocationNV + VkCommandBuffer commandBuffer + uint32_t coverageToColorLocation + + + void vkCmdSetCoverageModulationModeNV + VkCommandBuffer commandBuffer + VkCoverageModulationModeNV coverageModulationMode + + + void vkCmdSetCoverageModulationTableEnableNV + VkCommandBuffer commandBuffer + VkBool32 coverageModulationTableEnable + + + void vkCmdSetCoverageModulationTableNV + VkCommandBuffer commandBuffer + uint32_t coverageModulationTableCount + const float* pCoverageModulationTable + + + void vkCmdSetShadingRateImageEnableNV + VkCommandBuffer commandBuffer + VkBool32 shadingRateImageEnable + + + void vkCmdSetCoverageReductionModeNV + VkCommandBuffer commandBuffer + VkCoverageReductionModeNV coverageReductionMode + + + void vkCmdSetRepresentativeFragmentTestEnableNV + VkCommandBuffer commandBuffer + VkBool32 representativeFragmentTestEnable + + + VkResult vkCreatePrivateDataSlot + VkDevice device + const VkPrivateDataSlotCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPrivateDataSlot* pPrivateDataSlot + + + + void vkDestroyPrivateDataSlot + VkDevice device + VkPrivateDataSlot privateDataSlot + const VkAllocationCallbacks* pAllocator + + + + VkResult vkSetPrivateData + VkDevice device + VkObjectType objectType + uint64_t objectHandle + VkPrivateDataSlot privateDataSlot + uint64_t data + + + + void vkGetPrivateData + VkDevice device + VkObjectType objectType + uint64_t objectHandle + VkPrivateDataSlot privateDataSlot + uint64_t* pData + + + + void vkCmdCopyBuffer2 + VkCommandBuffer commandBuffer + const VkCopyBufferInfo2* pCopyBufferInfo + + + + void vkCmdCopyImage2 + VkCommandBuffer commandBuffer + const VkCopyImageInfo2* pCopyImageInfo + + + + void vkCmdBlitImage2 + VkCommandBuffer commandBuffer + const VkBlitImageInfo2* pBlitImageInfo + + + + void vkCmdCopyBufferToImage2 + VkCommandBuffer commandBuffer + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo + + + + void vkCmdCopyImageToBuffer2 + VkCommandBuffer commandBuffer + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo + + + + void vkCmdResolveImage2 + VkCommandBuffer commandBuffer + const VkResolveImageInfo2* pResolveImageInfo + + + + void vkCmdRefreshObjectsKHR + VkCommandBuffer commandBuffer + const VkRefreshObjectListKHR* pRefreshObjects + + + VkResult vkGetPhysicalDeviceRefreshableObjectTypesKHR + VkPhysicalDevice physicalDevice + uint32_t* pRefreshableObjectTypeCount + VkObjectType* pRefreshableObjectTypes + + + void vkCmdSetFragmentShadingRateKHR + VkCommandBuffer commandBuffer + const VkExtent2D* pFragmentSize + const VkFragmentShadingRateCombinerOpKHR combinerOps[2] + + + VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR + VkPhysicalDevice physicalDevice + uint32_t* pFragmentShadingRateCount + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates + + + void vkCmdSetFragmentShadingRateEnumNV + VkCommandBuffer commandBuffer + VkFragmentShadingRateNV shadingRate + const VkFragmentShadingRateCombinerOpKHR combinerOps[2] + + + void vkGetAccelerationStructureBuildSizesKHR + VkDevice device + VkAccelerationStructureBuildTypeKHR buildType + const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo + const uint32_t* pMaxPrimitiveCounts + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo + + + void vkCmdSetVertexInputEXT + VkCommandBuffer commandBuffer + uint32_t vertexBindingDescriptionCount + const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions + uint32_t vertexAttributeDescriptionCount + const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions + + + void vkCmdSetColorWriteEnableEXT + VkCommandBuffer commandBuffer + uint32_t attachmentCount + const VkBool32* pColorWriteEnables + + + void vkCmdSetEvent2 + VkCommandBuffer commandBuffer + VkEvent event + const VkDependencyInfo* pDependencyInfo + + + + void vkCmdResetEvent2 + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags2 stageMask + + + + void vkCmdWaitEvents2 + VkCommandBuffer commandBuffer + uint32_t eventCount + const VkEvent* pEvents + const VkDependencyInfo* pDependencyInfos + + + + void vkCmdPipelineBarrier2 + VkCommandBuffer commandBuffer + const VkDependencyInfo* pDependencyInfo + + + + VkResult vkQueueSubmit2 + VkQueue queue + uint32_t submitCount + const VkSubmitInfo2* pSubmits + VkFence fence + + + + void vkCmdWriteTimestamp2 + VkCommandBuffer commandBuffer + VkPipelineStageFlags2 stage + VkQueryPool queryPool + uint32_t query + + + + void vkCmdWriteBufferMarker2AMD + VkCommandBuffer commandBuffer + VkPipelineStageFlags2 stage + VkBuffer dstBuffer + VkDeviceSize dstOffset + uint32_t marker + + + void vkGetQueueCheckpointData2NV + VkQueue queue + uint32_t* pCheckpointDataCount + VkCheckpointData2NV* pCheckpointData + + + void vkGetCommandPoolMemoryConsumption + VkDevice device + VkCommandPool commandPool + VkCommandBuffer commandBuffer + VkCommandPoolMemoryConsumption* pConsumption + + + VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR + VkPhysicalDevice physicalDevice + const VkVideoProfileInfoKHR* pVideoProfile + VkVideoCapabilitiesKHR* pCapabilities + + + VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR + VkPhysicalDevice physicalDevice + const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo + uint32_t* pVideoFormatPropertyCount + VkVideoFormatPropertiesKHR* pVideoFormatProperties + + + VkResult vkCreateVideoSessionKHR + VkDevice device + const VkVideoSessionCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkVideoSessionKHR* pVideoSession + + + void vkDestroyVideoSessionKHR + VkDevice device + VkVideoSessionKHR videoSession + const VkAllocationCallbacks* pAllocator + + + VkResult vkCreateVideoSessionParametersKHR + VkDevice device + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkVideoSessionParametersKHR* pVideoSessionParameters + + + VkResult vkUpdateVideoSessionParametersKHR + VkDevice device + VkVideoSessionParametersKHR videoSessionParameters + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo + + + void vkDestroyVideoSessionParametersKHR + VkDevice device + VkVideoSessionParametersKHR videoSessionParameters + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetVideoSessionMemoryRequirementsKHR + VkDevice device + VkVideoSessionKHR videoSession + uint32_t* pMemoryRequirementsCount + VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements + + + VkResult vkBindVideoSessionMemoryKHR + VkDevice device + VkVideoSessionKHR videoSession + uint32_t bindSessionMemoryInfoCount + const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos + + + void vkCmdDecodeVideoKHR + VkCommandBuffer commandBuffer + const VkVideoDecodeInfoKHR* pDecodeInfo + + + void vkCmdBeginVideoCodingKHR + VkCommandBuffer commandBuffer + const VkVideoBeginCodingInfoKHR* pBeginInfo + + + void vkCmdControlVideoCodingKHR + VkCommandBuffer commandBuffer + const VkVideoCodingControlInfoKHR* pCodingControlInfo + + + void vkCmdEndVideoCodingKHR + VkCommandBuffer commandBuffer + const VkVideoEndCodingInfoKHR* pEndCodingInfo + + + void vkCmdEncodeVideoKHR + VkCommandBuffer commandBuffer + const VkVideoEncodeInfoKHR* pEncodeInfo + + + void vkCmdDecompressMemoryNV + VkCommandBuffer commandBuffer + uint32_t decompressRegionCount + const VkDecompressMemoryRegionNV* pDecompressMemoryRegions + + + void vkCmdDecompressMemoryIndirectCountNV + VkCommandBuffer commandBuffer + VkDeviceAddress indirectCommandsAddress + VkDeviceAddress indirectCommandsCountAddress + uint32_t stride + + + VkResult vkCreateCuModuleNVX + VkDevice device + const VkCuModuleCreateInfoNVX* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkCuModuleNVX* pModule + + + VkResult vkCreateCuFunctionNVX + VkDevice device + const VkCuFunctionCreateInfoNVX* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkCuFunctionNVX* pFunction + + + void vkDestroyCuModuleNVX + VkDevice device + VkCuModuleNVX module + const VkAllocationCallbacks* pAllocator + + + void vkDestroyCuFunctionNVX + VkDevice device + VkCuFunctionNVX function + const VkAllocationCallbacks* pAllocator + + + void vkCmdCuLaunchKernelNVX + VkCommandBuffer commandBuffer + const VkCuLaunchInfoNVX* pLaunchInfo + + + void vkGetDescriptorSetLayoutSizeEXT + VkDevice device + VkDescriptorSetLayout layout + VkDeviceSize* pLayoutSizeInBytes + + + void vkGetDescriptorSetLayoutBindingOffsetEXT + VkDevice device + VkDescriptorSetLayout layout + uint32_t binding + VkDeviceSize* pOffset + + + void vkGetDescriptorEXT + VkDevice device + const VkDescriptorGetInfoEXT* pDescriptorInfo + size_t dataSize + void* pDescriptor + + + void vkCmdBindDescriptorBuffersEXT + VkCommandBuffer commandBuffer + uint32_t bufferCount + const VkDescriptorBufferBindingInfoEXT* pBindingInfos + + + void vkCmdSetDescriptorBufferOffsetsEXT + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout layout + uint32_t firstSet + uint32_t setCount + const uint32_t* pBufferIndices + const VkDeviceSize* pOffsets + + + void vkCmdBindDescriptorBufferEmbeddedSamplersEXT + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout layout + uint32_t set + + + VkResult vkGetBufferOpaqueCaptureDescriptorDataEXT + VkDevice device + const VkBufferCaptureDescriptorDataInfoEXT* pInfo + void* pData + + + VkResult vkGetImageOpaqueCaptureDescriptorDataEXT + VkDevice device + const VkImageCaptureDescriptorDataInfoEXT* pInfo + void* pData + + + VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT + VkDevice device + const VkImageViewCaptureDescriptorDataInfoEXT* pInfo + void* pData + + + VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT + VkDevice device + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo + void* pData + + + VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT + VkDevice device + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo + void* pData + + + void vkSetDeviceMemoryPriorityEXT + VkDevice device + VkDeviceMemory memory + float priority + + + VkResult vkAcquireDrmDisplayEXT + VkPhysicalDevice physicalDevice + int32_t drmFd + VkDisplayKHR display + + + VkResult vkGetDrmDisplayEXT + VkPhysicalDevice physicalDevice + int32_t drmFd + uint32_t connectorId + VkDisplayKHR* display + + + VkResult vkWaitForPresentKHR + VkDevice device + VkSwapchainKHR swapchain + uint64_t presentId + uint64_t timeout + + + VkResult vkCreateBufferCollectionFUCHSIA + VkDevice device + const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBufferCollectionFUCHSIA* pCollection + + + VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA + VkDevice device + VkBufferCollectionFUCHSIA collection + const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo + + + VkResult vkSetBufferCollectionImageConstraintsFUCHSIA + VkDevice device + VkBufferCollectionFUCHSIA collection + const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo + + + void vkDestroyBufferCollectionFUCHSIA + VkDevice device + VkBufferCollectionFUCHSIA collection + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetBufferCollectionPropertiesFUCHSIA + VkDevice device + VkBufferCollectionFUCHSIA collection + VkBufferCollectionPropertiesFUCHSIA* pProperties + + + void vkCmdBeginRendering + VkCommandBuffer commandBuffer + const VkRenderingInfo* pRenderingInfo + + + + void vkCmdEndRendering + VkCommandBuffer commandBuffer + + + + + void vkGetDescriptorSetLayoutHostMappingInfoVALVE + VkDevice device + const VkDescriptorSetBindingReferenceVALVE* pBindingReference + VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping + + + void vkGetDescriptorSetHostMappingVALVE + VkDevice device + VkDescriptorSet descriptorSet + void** ppData + + + VkResult vkCreateMicromapEXT + VkDevice device + const VkMicromapCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkMicromapEXT* pMicromap + + + void vkCmdBuildMicromapsEXT + VkCommandBuffer commandBuffer + uint32_t infoCount + const VkMicromapBuildInfoEXT* pInfos + + + VkResult vkBuildMicromapsEXT + VkDevice device + VkDeferredOperationKHR deferredOperation + uint32_t infoCount + const VkMicromapBuildInfoEXT* pInfos + + + void vkDestroyMicromapEXT + VkDevice device + VkMicromapEXT micromap + const VkAllocationCallbacks* pAllocator + + + void vkCmdCopyMicromapEXT + VkCommandBuffer commandBuffer + const VkCopyMicromapInfoEXT* pInfo + + + VkResult vkCopyMicromapEXT + VkDevice device + VkDeferredOperationKHR deferredOperation + const VkCopyMicromapInfoEXT* pInfo + + + void vkCmdCopyMicromapToMemoryEXT + VkCommandBuffer commandBuffer + const VkCopyMicromapToMemoryInfoEXT* pInfo + + + VkResult vkCopyMicromapToMemoryEXT + VkDevice device + VkDeferredOperationKHR deferredOperation + const VkCopyMicromapToMemoryInfoEXT* pInfo + + + void vkCmdCopyMemoryToMicromapEXT + VkCommandBuffer commandBuffer + const VkCopyMemoryToMicromapInfoEXT* pInfo + + + VkResult vkCopyMemoryToMicromapEXT + VkDevice device + VkDeferredOperationKHR deferredOperation + const VkCopyMemoryToMicromapInfoEXT* pInfo + + + void vkCmdWriteMicromapsPropertiesEXT + VkCommandBuffer commandBuffer + uint32_t micromapCount + const VkMicromapEXT* pMicromaps + VkQueryType queryType + VkQueryPool queryPool + uint32_t firstQuery + + + VkResult vkWriteMicromapsPropertiesEXT + VkDevice device + uint32_t micromapCount + const VkMicromapEXT* pMicromaps + VkQueryType queryType + size_t dataSize + void* pData + size_t stride + + + void vkGetDeviceMicromapCompatibilityEXT + VkDevice device + const VkMicromapVersionInfoEXT* pVersionInfo + VkAccelerationStructureCompatibilityKHR* pCompatibility + + + void vkGetMicromapBuildSizesEXT + VkDevice device + VkAccelerationStructureBuildTypeKHR buildType + const VkMicromapBuildInfoEXT* pBuildInfo + VkMicromapBuildSizesInfoEXT* pSizeInfo + + + void vkGetShaderModuleIdentifierEXT + VkDevice device + VkShaderModule shaderModule + VkShaderModuleIdentifierEXT* pIdentifier + + + void vkGetShaderModuleCreateInfoIdentifierEXT + VkDevice device + const VkShaderModuleCreateInfo* pCreateInfo + VkShaderModuleIdentifierEXT* pIdentifier + + + void vkGetImageSubresourceLayout2EXT + VkDevice device + VkImage image + const VkImageSubresource2EXT* pSubresource + VkSubresourceLayout2EXT* pLayout + + + VkResult vkGetPipelinePropertiesEXT + VkDevice device + const VkPipelineInfoEXT* pPipelineInfo + VkBaseOutStructure* pPipelineProperties + + + void vkExportMetalObjectsEXT + VkDevice device + VkExportMetalObjectsInfoEXT* pMetalObjectsInfo + + + VkResult vkGetFramebufferTilePropertiesQCOM + VkDevice device + VkFramebuffer framebuffer + uint32_t* pPropertiesCount + VkTilePropertiesQCOM* pProperties + + + VkResult vkGetDynamicRenderingTilePropertiesQCOM + VkDevice device + const VkRenderingInfo* pRenderingInfo + VkTilePropertiesQCOM* pProperties + + + VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV + VkPhysicalDevice physicalDevice + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo + uint32_t* pFormatCount + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties + + + VkResult vkCreateOpticalFlowSessionNV + VkDevice device + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkOpticalFlowSessionNV* pSession + + + void vkDestroyOpticalFlowSessionNV + VkDevice device + VkOpticalFlowSessionNV session + const VkAllocationCallbacks* pAllocator + + + VkResult vkBindOpticalFlowSessionImageNV + VkDevice device + VkOpticalFlowSessionNV session + VkOpticalFlowSessionBindingPointNV bindingPoint + VkImageView view + VkImageLayout layout + + + void vkCmdOpticalFlowExecuteNV + VkCommandBuffer commandBuffer + VkOpticalFlowSessionNV session + const VkOpticalFlowExecuteInfoNV* pExecuteInfo + + + VkResult vkGetDeviceFaultInfoEXT + VkDevice device + VkDeviceFaultCountsEXT* pFaultCounts + VkDeviceFaultInfoEXT* pFaultInfo + + + VkResult vkReleaseSwapchainImagesEXT + VkDevice device + const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo + + + VkResult vkMapMemory2KHR + VkDevice device + const VkMemoryMapInfoKHR* pMemoryMapInfo + void** ppData + + + VkResult vkUnmapMemory2KHR + VkDevice device + const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo + + + VkResult vkCreateShadersEXT + VkDevice device + uint32_t createInfoCount + const VkShaderCreateInfoEXT* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkShaderEXT* pShaders + + + void vkDestroyShaderEXT + VkDevice device + VkShaderEXT shader + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetShaderBinaryDataEXT + VkDevice device + VkShaderEXT shader + size_t* pDataSize + void* pData + + + void vkCmdBindShadersEXT + VkCommandBuffer commandBuffer + uint32_t stageCount + const VkShaderStageFlagBits* pStages + const VkShaderEXT* pShaders + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + offset 1 reserved for the old VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX enum + offset 2 reserved for the old VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX enum + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Additional dependent types / tokens extending enumerants, not explicitly mentioned + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Additional dependent types / tokens extending enumerants, not explicitly mentioned + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This duplicates definitions in VK_KHR_device_group below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VK_ANDROID_native_buffer is used between the Android Vulkan loader and drivers to implement the WSI extensions. It is not exposed to applications and uses types that are not part of Android's stable public API, so it is left disabled to keep it out of the standard Vulkan headers. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This duplicates definitions in other extensions, below + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + enum offset=0 was mistakenly used for the 1.1 core enum + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES + (value=1000094000). Fortunately, no conflict resulted. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This extension requires buffer_device_address functionality. + VK_EXT_buffer_device_address is also acceptable, but since it is deprecated the KHR version is preferred. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + These enums are present only to inform downstream + consumers like KTX2. There is no actual Vulkan extension + corresponding to the enums. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT and + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT + were not promoted to Vulkan 1.3. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VkPhysicalDevice4444FormatsFeaturesEXT and + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT + were not promoted to Vulkan 1.3. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + NV internal use only + + + + + + + + + + + + + + + + + + + + + + + + + + NV internal use only + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +