mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-20 05:16:01 +00:00
perf(vkbridge): client-named descriptor sets, allocated without a round trip
Where the client keeps a pool's books and knows every layout, it names the sets itself (top bit set) and sends vkbAllocDescSets asynchronously; the server allocates the driver's sets and translates the names in dispatch wrappers (updates, template updates, binds, frees) and forgets them on pool reset/destroy. All-or-nothing; a full pool still answers OUT_OF_POOL_MEMORY. d3d11_bench 1000 draws: 1.43 -> 1.12 ms/frame (native 0.30); the only synchronous call left per frame is vkWaitSemaphores. Host suite 14/14. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01S1U9H1evGNjHRQ3wRUdv5V
This commit is contained in:
1 parent
850c929967
commit
0e7f8e7170
10 files changed
+689
-289
No files matched your search
@@ -105,6 +105,7 @@ void vkb_proc_cleanup(vkb_srv_proc *p)
|
||||
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_dsmap_device_destroy(t);
|
||||
vkb_pcache_device_destroy(t);
|
||||
vkb_emu_device_destroy(t);
|
||||
vkb_mem_free_all(t);
|
||||
|
||||
@@ -0,0 +1,337 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Descriptor sets named by the client. Where the client keeps a pool's books it knows an
|
||||
* allocation will succeed, so it names the sets itself (VKB_DS_TAG | n) and sends the allocation
|
||||
* without waiting (vkbAllocDescSets) - DXVK allocates a set or two per draw, and a round trip
|
||||
* each was most of the bridge's remaining cost per frame. Here those names map to the driver's
|
||||
* sets: wrappers in the device's dispatch table translate them wherever a set goes back to the
|
||||
* driver (updates, template updates, binds, frees), and a pool's reset or destruction forgets its
|
||||
* sets. Sets the server named itself (the synchronous path) pass through untouched.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "vkb_server.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#define VKB_DS_TAG (1ull << 63)
|
||||
#define DS_BUCKETS 8192
|
||||
#define DS_LOCAL 64
|
||||
|
||||
typedef struct ds_ent {
|
||||
uint64_t id;
|
||||
VkDescriptorSet set;
|
||||
struct ds_ent *next; /* bucket chain */
|
||||
struct ds_ent *pool_next; /* the pool's sets */
|
||||
} ds_ent;
|
||||
|
||||
typedef struct ds_pool {
|
||||
VkDescriptorPool pool;
|
||||
ds_ent *sets;
|
||||
struct ds_pool *next;
|
||||
} ds_pool;
|
||||
|
||||
typedef struct vkb_dsmap {
|
||||
pthread_mutex_t lock;
|
||||
ds_ent *buckets[DS_BUCKETS];
|
||||
ds_pool *pools;
|
||||
int warned;
|
||||
PFN_vkAllocateDescriptorSets allocate;
|
||||
PFN_vkUpdateDescriptorSets update;
|
||||
PFN_vkUpdateDescriptorSetWithTemplate update_template;
|
||||
PFN_vkCmdBindDescriptorSets bind;
|
||||
PFN_vkCmdBindDescriptorSets2 bind2;
|
||||
PFN_vkFreeDescriptorSets free_sets;
|
||||
PFN_vkResetDescriptorPool reset_pool;
|
||||
PFN_vkDestroyDescriptorPool destroy_pool;
|
||||
} vkb_dsmap;
|
||||
|
||||
static unsigned bucket(uint64_t id)
|
||||
{
|
||||
id *= 0x9e3779b97f4a7c15ull;
|
||||
return (unsigned)(id >> 51) & (DS_BUCKETS - 1);
|
||||
}
|
||||
|
||||
static vkb_dsmap *cur(void)
|
||||
{
|
||||
vkb_srv_table *t = vkb_srv_current_table();
|
||||
return t ? t->dsmap : NULL;
|
||||
}
|
||||
|
||||
static int tagged(VkDescriptorSet s)
|
||||
{
|
||||
return ((uint64_t)s & VKB_DS_TAG) != 0;
|
||||
}
|
||||
|
||||
/* The driver's set for a client name; VK_NULL_HANDLE when its allocation failed. */
|
||||
static VkDescriptorSet lookup(vkb_dsmap *m, VkDescriptorSet s)
|
||||
{
|
||||
if (!tagged(s)) return s;
|
||||
uint64_t id = (uint64_t)s;
|
||||
pthread_mutex_lock(&m->lock);
|
||||
ds_ent *e = m->buckets[bucket(id)];
|
||||
while (e && e->id != id) e = e->next;
|
||||
VkDescriptorSet r = e ? e->set : VK_NULL_HANDLE;
|
||||
pthread_mutex_unlock(&m->lock);
|
||||
return r;
|
||||
}
|
||||
|
||||
static void missing(vkb_dsmap *m, const char *where)
|
||||
{
|
||||
if (__atomic_fetch_add(&m->warned, 1, __ATOMIC_RELAXED) < 20)
|
||||
VKB_ERR("%s: a descriptor set the client allocated ahead does not exist (its allocation failed); skipped", where);
|
||||
}
|
||||
|
||||
static ds_pool *pool_get(vkb_dsmap *m, VkDescriptorPool pool, int create)
|
||||
{
|
||||
for (ds_pool *p = m->pools; p; p = p->next)
|
||||
if (p->pool == pool) return p;
|
||||
if (!create) return NULL;
|
||||
ds_pool *p = calloc(1, sizeof(*p));
|
||||
if (!p) return NULL;
|
||||
p->pool = pool;
|
||||
p->next = m->pools;
|
||||
m->pools = p;
|
||||
return p;
|
||||
}
|
||||
|
||||
/* Forgets the pool's sets (a reset or destruction freed them); the record goes with destroy. */
|
||||
static void pool_forget(vkb_dsmap *m, VkDescriptorPool pool, int destroy)
|
||||
{
|
||||
pthread_mutex_lock(&m->lock);
|
||||
for (ds_pool **pp = &m->pools; *pp; pp = &(*pp)->next) {
|
||||
ds_pool *p = *pp;
|
||||
if (p->pool != pool) continue;
|
||||
while (p->sets) {
|
||||
ds_ent *e = p->sets;
|
||||
p->sets = e->pool_next;
|
||||
ds_ent **bp = &m->buckets[bucket(e->id)];
|
||||
while (*bp && *bp != e) bp = &(*bp)->next;
|
||||
if (*bp) *bp = e->next;
|
||||
free(e);
|
||||
}
|
||||
if (destroy) {
|
||||
*pp = p->next;
|
||||
free(p);
|
||||
}
|
||||
break;
|
||||
}
|
||||
pthread_mutex_unlock(&m->lock);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ the allocation request */
|
||||
|
||||
/* vkbAllocDescSets: device, pool, count, then per set its layout and the client's name. */
|
||||
void vkb_sv_vkbAllocDescSets(vkb_srv_call *c)
|
||||
{
|
||||
VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d);
|
||||
VkDescriptorPool pool;
|
||||
vkb_dec_bytes(&c->d, &pool, sizeof(pool));
|
||||
uint32_t n = vkb_dec_u32(&c->d);
|
||||
if (c->d.err || !c->table || !c->table->dsmap || n == 0 || n > 4096) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
vkb_dsmap *m = c->table->dsmap;
|
||||
VkDescriptorSetLayout layouts_local[DS_LOCAL], *layouts = n <= DS_LOCAL ? layouts_local : malloc(n * sizeof(*layouts));
|
||||
uint64_t ids_local[DS_LOCAL], *ids = n <= DS_LOCAL ? ids_local : malloc(n * sizeof(*ids));
|
||||
VkDescriptorSet sets_local[DS_LOCAL], *sets = n <= DS_LOCAL ? sets_local : malloc(n * sizeof(*sets));
|
||||
if (!layouts || !ids || !sets) goto out;
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
vkb_dec_bytes(&c->d, &layouts[i], sizeof(layouts[i]));
|
||||
ids[i] = vkb_dec_u64(&c->d);
|
||||
}
|
||||
if (c->d.err) {
|
||||
vkb_srv_bad_message(c);
|
||||
goto out;
|
||||
}
|
||||
VkDescriptorSetAllocateInfo ai = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, NULL, pool, n, layouts};
|
||||
VkResult r = m->allocate(dev, &ai, sets);
|
||||
if (r != VK_SUCCESS) {
|
||||
VKB_ERR("allocating %u descriptor sets the client named ahead failed: %d (the client's pool books disagree "
|
||||
"with the driver)", n, r);
|
||||
goto out;
|
||||
}
|
||||
pthread_mutex_lock(&m->lock);
|
||||
ds_pool *p = pool_get(m, pool, 1);
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
ds_ent *e = malloc(sizeof(*e));
|
||||
if (!e || !p) {
|
||||
free(e);
|
||||
break;
|
||||
}
|
||||
e->id = ids[i];
|
||||
e->set = sets[i];
|
||||
unsigned b = bucket(e->id);
|
||||
e->next = m->buckets[b];
|
||||
m->buckets[b] = e;
|
||||
e->pool_next = p->sets;
|
||||
p->sets = e;
|
||||
}
|
||||
pthread_mutex_unlock(&m->lock);
|
||||
out:
|
||||
if (layouts != layouts_local) free(layouts);
|
||||
if (ids != ids_local) free(ids);
|
||||
if (sets != sets_local) free(sets);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ wrappers */
|
||||
|
||||
static void VKAPI_CALL ds_UpdateDescriptorSets(VkDevice device, uint32_t nw, const VkWriteDescriptorSet *w, uint32_t nc,
|
||||
const VkCopyDescriptorSet *cp)
|
||||
{
|
||||
vkb_dsmap *m = cur();
|
||||
int any = 0;
|
||||
for (uint32_t i = 0; i < nw && !any; i++) any = tagged(w[i].dstSet);
|
||||
for (uint32_t i = 0; i < nc && !any; i++) any = tagged(cp[i].srcSet) || tagged(cp[i].dstSet);
|
||||
if (!any) {
|
||||
m->update(device, nw, w, nc, cp);
|
||||
return;
|
||||
}
|
||||
VkWriteDescriptorSet w_local[DS_LOCAL], *w2 = nw <= DS_LOCAL ? w_local : malloc(nw * sizeof(*w2));
|
||||
VkCopyDescriptorSet c_local[DS_LOCAL], *c2 = nc <= DS_LOCAL ? c_local : malloc(nc * sizeof(*c2));
|
||||
if ((nw && !w2) || (nc && !c2)) goto out;
|
||||
uint32_t kw = 0, kc = 0;
|
||||
for (uint32_t i = 0; i < nw; i++) {
|
||||
w2[kw] = w[i];
|
||||
w2[kw].dstSet = lookup(m, w[i].dstSet);
|
||||
if (w2[kw].dstSet) kw++;
|
||||
else missing(m, "vkUpdateDescriptorSets");
|
||||
}
|
||||
for (uint32_t i = 0; i < nc; i++) {
|
||||
c2[kc] = cp[i];
|
||||
c2[kc].srcSet = lookup(m, cp[i].srcSet);
|
||||
c2[kc].dstSet = lookup(m, cp[i].dstSet);
|
||||
if (c2[kc].srcSet && c2[kc].dstSet) kc++;
|
||||
else missing(m, "vkUpdateDescriptorSets (copy)");
|
||||
}
|
||||
if (kw || kc) m->update(device, kw, w2, kc, c2);
|
||||
out:
|
||||
if (w2 != w_local) free(w2);
|
||||
if (c2 != c_local) free(c2);
|
||||
}
|
||||
|
||||
static void VKAPI_CALL ds_UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet set, VkDescriptorUpdateTemplate tmpl,
|
||||
const void *data)
|
||||
{
|
||||
vkb_dsmap *m = cur();
|
||||
VkDescriptorSet s = lookup(m, set);
|
||||
if (!s) {
|
||||
missing(m, "vkUpdateDescriptorSetWithTemplate");
|
||||
return;
|
||||
}
|
||||
m->update_template(device, s, tmpl, data);
|
||||
}
|
||||
|
||||
/* Translates n sets into out; 0 when one of them does not exist. */
|
||||
static int translate(vkb_dsmap *m, uint32_t n, const VkDescriptorSet *in, VkDescriptorSet *out)
|
||||
{
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
/* VK_NULL_HANDLE is allowed in binds (graphicsPipelineLibrary) and stays so. */
|
||||
out[i] = in[i] ? lookup(m, in[i]) : VK_NULL_HANDLE;
|
||||
if (in[i] && !out[i]) return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void VKAPI_CALL ds_CmdBindDescriptorSets(VkCommandBuffer cb, VkPipelineBindPoint bp, VkPipelineLayout layout, uint32_t first,
|
||||
uint32_t n, const VkDescriptorSet *sets, uint32_t ndyn, const uint32_t *dyn)
|
||||
{
|
||||
vkb_dsmap *m = cur();
|
||||
VkDescriptorSet local[DS_LOCAL], *s = n <= DS_LOCAL ? local : malloc(n * sizeof(*s));
|
||||
if (!s) return;
|
||||
if (translate(m, n, sets, s)) m->bind(cb, bp, layout, first, n, s, ndyn, dyn);
|
||||
else missing(m, "vkCmdBindDescriptorSets");
|
||||
if (s != local) free(s);
|
||||
}
|
||||
|
||||
static void VKAPI_CALL ds_CmdBindDescriptorSets2(VkCommandBuffer cb, const VkBindDescriptorSetsInfo *info)
|
||||
{
|
||||
vkb_dsmap *m = cur();
|
||||
uint32_t n = info->descriptorSetCount;
|
||||
VkDescriptorSet local[DS_LOCAL], *s = n <= DS_LOCAL ? local : malloc(n * sizeof(*s));
|
||||
if (!s) return;
|
||||
VkBindDescriptorSetsInfo i2 = *info;
|
||||
i2.pDescriptorSets = s;
|
||||
if (translate(m, n, info->pDescriptorSets, s)) m->bind2(cb, &i2);
|
||||
else missing(m, "vkCmdBindDescriptorSets2");
|
||||
if (s != local) free(s);
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL ds_FreeDescriptorSets(VkDevice device, VkDescriptorPool pool, uint32_t n, const VkDescriptorSet *sets)
|
||||
{
|
||||
vkb_dsmap *m = cur();
|
||||
VkDescriptorSet local[DS_LOCAL], *s = n <= DS_LOCAL ? local : malloc(n * sizeof(*s));
|
||||
if (!s) return VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||
/* Named sets come only from pools without FREE_DESCRIPTOR_SET (the client keeps no books on
|
||||
* those), so this is an app error at worst: what does not exist is left out. */
|
||||
uint32_t k = 0;
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
VkDescriptorSet t = sets[i] ? lookup(m, sets[i]) : VK_NULL_HANDLE;
|
||||
if (t || !sets[i]) s[k++] = t;
|
||||
}
|
||||
VkResult r = k ? m->free_sets(device, pool, k, s) : VK_SUCCESS;
|
||||
if (s != local) free(s);
|
||||
return r;
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL ds_ResetDescriptorPool(VkDevice device, VkDescriptorPool pool, VkDescriptorPoolResetFlags flags)
|
||||
{
|
||||
vkb_dsmap *m = cur();
|
||||
pool_forget(m, pool, 0);
|
||||
return m->reset_pool(device, pool, flags);
|
||||
}
|
||||
|
||||
static void VKAPI_CALL ds_DestroyDescriptorPool(VkDevice device, VkDescriptorPool pool, const VkAllocationCallbacks *a)
|
||||
{
|
||||
vkb_dsmap *m = cur();
|
||||
if (pool) pool_forget(m, pool, 1);
|
||||
m->destroy_pool(device, pool, a);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ device hooks */
|
||||
|
||||
void vkb_dsmap_device_init(vkb_srv_table *t)
|
||||
{
|
||||
vkb_dispatch *dt = &t->dt;
|
||||
if (!dt->vkAllocateDescriptorSets || !dt->vkUpdateDescriptorSets || !dt->vkCmdBindDescriptorSets ||
|
||||
!dt->vkResetDescriptorPool || !dt->vkDestroyDescriptorPool || !dt->vkFreeDescriptorSets)
|
||||
return;
|
||||
vkb_dsmap *m = calloc(1, sizeof(*m));
|
||||
if (!m) return;
|
||||
pthread_mutex_init(&m->lock, NULL);
|
||||
m->allocate = dt->vkAllocateDescriptorSets;
|
||||
m->update = dt->vkUpdateDescriptorSets;
|
||||
m->update_template = dt->vkUpdateDescriptorSetWithTemplate;
|
||||
m->bind = dt->vkCmdBindDescriptorSets;
|
||||
m->bind2 = dt->vkCmdBindDescriptorSets2;
|
||||
m->free_sets = dt->vkFreeDescriptorSets;
|
||||
m->reset_pool = dt->vkResetDescriptorPool;
|
||||
m->destroy_pool = dt->vkDestroyDescriptorPool;
|
||||
dt->vkUpdateDescriptorSets = ds_UpdateDescriptorSets;
|
||||
if (m->update_template) dt->vkUpdateDescriptorSetWithTemplate = ds_UpdateDescriptorSetWithTemplate;
|
||||
dt->vkCmdBindDescriptorSets = ds_CmdBindDescriptorSets;
|
||||
if (m->bind2) dt->vkCmdBindDescriptorSets2 = ds_CmdBindDescriptorSets2;
|
||||
dt->vkFreeDescriptorSets = ds_FreeDescriptorSets;
|
||||
dt->vkResetDescriptorPool = ds_ResetDescriptorPool;
|
||||
dt->vkDestroyDescriptorPool = ds_DestroyDescriptorPool;
|
||||
t->dsmap = m;
|
||||
}
|
||||
|
||||
void vkb_dsmap_device_destroy(vkb_srv_table *t)
|
||||
{
|
||||
vkb_dsmap *m = t->dsmap;
|
||||
if (!m) return;
|
||||
vkb_dispatch *dt = &t->dt;
|
||||
dt->vkUpdateDescriptorSets = m->update;
|
||||
if (m->update_template) dt->vkUpdateDescriptorSetWithTemplate = m->update_template;
|
||||
dt->vkCmdBindDescriptorSets = m->bind;
|
||||
if (m->bind2) dt->vkCmdBindDescriptorSets2 = m->bind2;
|
||||
dt->vkFreeDescriptorSets = m->free_sets;
|
||||
dt->vkResetDescriptorPool = m->reset_pool;
|
||||
dt->vkDestroyDescriptorPool = m->destroy_pool;
|
||||
while (m->pools) pool_forget(m, m->pools->pool, 1);
|
||||
pthread_mutex_destroy(&m->lock);
|
||||
free(m);
|
||||
t->dsmap = NULL;
|
||||
}
|
||||
@@ -295,6 +295,7 @@ void vkb_sv_vkCreateDevice(vkb_srv_call *c)
|
||||
} else {
|
||||
vkb_emu_device_init(t, emu);
|
||||
vkb_pcache_device_init(t);
|
||||
vkb_dsmap_device_init(t);
|
||||
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]);
|
||||
@@ -317,6 +318,7 @@ void vkb_sv_vkDestroyDevice(vkb_srv_call *c)
|
||||
return;
|
||||
}
|
||||
vkb_table_unregister(t);
|
||||
vkb_dsmap_device_destroy(t);
|
||||
vkb_pcache_device_destroy(t);
|
||||
vkb_emu_device_destroy(t);
|
||||
vkb_mem_free_all(t);
|
||||
|
||||
@@ -86,6 +86,7 @@ typedef struct vkb_srv_table {
|
||||
vkb_srv_mem *mems[256]; /* hash by handle */
|
||||
struct vkb_emu_device *emu;
|
||||
struct vkb_pcache *pcache; /* server_pcache.c */
|
||||
struct vkb_dsmap *dsmap; /* server_dsmap.c */
|
||||
} vkb_srv_table;
|
||||
|
||||
/* server_main.c */
|
||||
@@ -93,6 +94,10 @@ extern PFN_vkGetInstanceProcAddr vkb_gipa;
|
||||
extern vkb_dispatch vkb_global_dt;
|
||||
extern int vkb_verbose;
|
||||
|
||||
/* server_dsmap.c */
|
||||
void vkb_dsmap_device_init(vkb_srv_table *t);
|
||||
void vkb_dsmap_device_destroy(vkb_srv_table *t);
|
||||
|
||||
/* server_pcache.c */
|
||||
void vkb_pcache_set_dir(const char *dir);
|
||||
void vkb_pcache_device_init(vkb_srv_table *t);
|
||||
|
||||
@@ -528,6 +528,49 @@ static VkResult ds_refill(VkDevice device, ds_pool *p, const ds_layout *l, ds_ca
|
||||
return r;
|
||||
}
|
||||
|
||||
/*
|
||||
* Sets the client names itself: with the pool's books kept and every layout known, whether the
|
||||
* allocation fits is known here, so the sets get names (VKB_DS_TAG | n) at once and the server
|
||||
* allocates the driver's sets without a reply (server_dsmap.c). All or nothing, as the spec has
|
||||
* it. VK_ERROR_UNKNOWN: not for this path (a layout the books cannot follow).
|
||||
*/
|
||||
#define VKB_DS_TAG (1ull << 63)
|
||||
#define DS_NAMED_MAX 1024
|
||||
|
||||
static VkResult ds_alloc_named(VkDevice device, ds_pool *p, const VkDescriptorSetAllocateInfo *ai, VkDescriptorSet *out)
|
||||
{
|
||||
static uint64_t next_name;
|
||||
uint32_t n = ai->descriptorSetCount;
|
||||
if (!n || n > DS_NAMED_MAX) return VK_ERROR_UNKNOWN;
|
||||
uint64_t need[DS_TYPES] = {0};
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
const ds_layout *l = layout_find(ai->pSetLayouts[i]);
|
||||
if (!l || !l->known) return VK_ERROR_UNKNOWN;
|
||||
for (int t = 0; t < DS_TYPES; t++) need[t] += l->count[t];
|
||||
}
|
||||
if (n > p->sets_left) return VK_ERROR_OUT_OF_POOL_MEMORY;
|
||||
for (int t = 0; t < DS_TYPES; t++)
|
||||
if (need[t] > p->left[t]) return VK_ERROR_OUT_OF_POOL_MEMORY;
|
||||
vkb_device *dev = vkb_dev(device);
|
||||
vkb_call c;
|
||||
vkb_call_begin(&c, VKB_CMD_vkbAllocDescSets, dev->obj.table);
|
||||
vkb_enc_u64(&c.e, dev->obj.remote);
|
||||
vkb_enc_bytes(&c.e, &ai->descriptorPool, sizeof(ai->descriptorPool));
|
||||
vkb_enc_u32(&c.e, n);
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
out[i] = (VkDescriptorSet)(VKB_DS_TAG | __atomic_add_fetch(&next_name, 1, __ATOMIC_RELAXED));
|
||||
vkb_enc_bytes(&c.e, &ai->pSetLayouts[i], sizeof(ai->pSetLayouts[i]));
|
||||
vkb_enc_u64(&c.e, (uint64_t)out[i]);
|
||||
}
|
||||
if (!vkb_call_exec_async(&c)) {
|
||||
for (uint32_t i = 0; i < n; i++) out[i] = VK_NULL_HANDLE;
|
||||
return VK_ERROR_DEVICE_LOST;
|
||||
}
|
||||
p->sets_left -= n;
|
||||
for (int t = 0; t < DS_TYPES; t++) p->left[t] -= (uint32_t)need[t];
|
||||
return VK_SUCCESS;
|
||||
}
|
||||
|
||||
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *ai, VkDescriptorSet *out)
|
||||
{
|
||||
/* Variable descriptor counts and the like are per allocation: those go straight through. */
|
||||
@@ -538,6 +581,13 @@ VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateDescriptorSets(VkDevice device,
|
||||
pthread_mutex_unlock(&ds_lock);
|
||||
return vkb_wire_vkAllocateDescriptorSets(device, ai, out);
|
||||
}
|
||||
if (p->books) {
|
||||
VkResult nr = ds_alloc_named(device, p, ai, out);
|
||||
if (nr != VK_ERROR_UNKNOWN) {
|
||||
pthread_mutex_unlock(&ds_lock);
|
||||
return nr;
|
||||
}
|
||||
}
|
||||
VkResult r = VK_SUCCESS;
|
||||
uint32_t done = 0;
|
||||
for (; done < ai->descriptorSetCount; done++) {
|
||||
|
||||
@@ -383,7 +383,7 @@ SERVER_DISPATCH_EXTRA = ['vkMapMemory', 'vkUnmapMemory', 'vkGetMemoryHostPointer
|
||||
'vkUpdateDescriptorSetWithTemplate', 'vkCmdPushDescriptorSetWithTemplateKHR']
|
||||
dispatch_cmds = sorted(set(wire_cmds) | {reg.canon_cmd(c) for c in SERVER_DISPATCH_EXTRA})
|
||||
# Wire-only helpers that are not Vulkan commands (handled by hand on both sides).
|
||||
EXTRA_WIRE = ['vkbHello', 'vkbQueryServer', 'vkbDescUpdateRaw', 'vkbPushDescRaw']
|
||||
EXTRA_WIRE = ['vkbHello', 'vkbQueryServer', 'vkbDescUpdateRaw', 'vkbPushDescRaw', 'vkbAllocDescSets']
|
||||
|
||||
# --------------------------------------------------------------------------------------------
|
||||
# Struct closure: every struct reachable from wire commands (params, members, pNext extenders).
|
||||
|
||||
+289
-288
@@ -12,299 +12,300 @@
|
||||
#include <stdint.h>
|
||||
typedef struct vkb_enc vkb_enc;
|
||||
typedef struct vkb_dec vkb_dec;
|
||||
#define VKB_PROTOCOL_HASH 0x8573c85f1e3900bdULL
|
||||
#define VKB_PROTOCOL_HASH 0xa9af75dc848727baULL
|
||||
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_vkBindTensorMemoryARM = 12,
|
||||
VKB_CMD_vkCmdBeginConditionalRenderingEXT = 13,
|
||||
VKB_CMD_vkCmdBeginCustomResolveEXT = 14,
|
||||
VKB_CMD_vkCmdBeginQuery = 15,
|
||||
VKB_CMD_vkCmdBeginQueryIndexedEXT = 16,
|
||||
VKB_CMD_vkCmdBeginRenderPass = 17,
|
||||
VKB_CMD_vkCmdBeginRenderPass2 = 18,
|
||||
VKB_CMD_vkCmdBeginRendering = 19,
|
||||
VKB_CMD_vkCmdBeginTransformFeedbackEXT = 20,
|
||||
VKB_CMD_vkCmdBindDescriptorSets = 21,
|
||||
VKB_CMD_vkCmdBindDescriptorSets2 = 22,
|
||||
VKB_CMD_vkCmdBindIndexBuffer = 23,
|
||||
VKB_CMD_vkCmdBindIndexBuffer2 = 24,
|
||||
VKB_CMD_vkCmdBindPipeline = 25,
|
||||
VKB_CMD_vkCmdBindTransformFeedbackBuffersEXT = 26,
|
||||
VKB_CMD_vkCmdBindVertexBuffers = 27,
|
||||
VKB_CMD_vkCmdBindVertexBuffers2 = 28,
|
||||
VKB_CMD_vkCmdBlitImage = 29,
|
||||
VKB_CMD_vkCmdBlitImage2 = 30,
|
||||
VKB_CMD_vkCmdClearAttachments = 31,
|
||||
VKB_CMD_vkCmdClearColorImage = 32,
|
||||
VKB_CMD_vkCmdClearDepthStencilImage = 33,
|
||||
VKB_CMD_vkCmdCopyBuffer = 34,
|
||||
VKB_CMD_vkCmdCopyBuffer2 = 35,
|
||||
VKB_CMD_vkCmdCopyBufferToImage = 36,
|
||||
VKB_CMD_vkCmdCopyBufferToImage2 = 37,
|
||||
VKB_CMD_vkCmdCopyImage = 38,
|
||||
VKB_CMD_vkCmdCopyImage2 = 39,
|
||||
VKB_CMD_vkCmdCopyImageToBuffer = 40,
|
||||
VKB_CMD_vkCmdCopyImageToBuffer2 = 41,
|
||||
VKB_CMD_vkCmdCopyQueryPoolResults = 42,
|
||||
VKB_CMD_vkCmdCopyTensorARM = 43,
|
||||
VKB_CMD_vkCmdDispatch = 44,
|
||||
VKB_CMD_vkCmdDispatchBase = 45,
|
||||
VKB_CMD_vkCmdDispatchIndirect = 46,
|
||||
VKB_CMD_vkCmdDraw = 47,
|
||||
VKB_CMD_vkCmdDrawIndexed = 48,
|
||||
VKB_CMD_vkCmdDrawIndexedIndirect = 49,
|
||||
VKB_CMD_vkCmdDrawIndexedIndirectCount = 50,
|
||||
VKB_CMD_vkCmdDrawIndirect = 51,
|
||||
VKB_CMD_vkCmdDrawIndirectByteCountEXT = 52,
|
||||
VKB_CMD_vkCmdDrawIndirectCount = 53,
|
||||
VKB_CMD_vkCmdDrawMultiEXT = 54,
|
||||
VKB_CMD_vkCmdDrawMultiIndexedEXT = 55,
|
||||
VKB_CMD_vkCmdEndConditionalRenderingEXT = 56,
|
||||
VKB_CMD_vkCmdEndQuery = 57,
|
||||
VKB_CMD_vkCmdEndQueryIndexedEXT = 58,
|
||||
VKB_CMD_vkCmdEndRenderPass = 59,
|
||||
VKB_CMD_vkCmdEndRenderPass2 = 60,
|
||||
VKB_CMD_vkCmdEndRendering = 61,
|
||||
VKB_CMD_vkCmdEndRendering2KHR = 62,
|
||||
VKB_CMD_vkCmdEndTransformFeedbackEXT = 63,
|
||||
VKB_CMD_vkCmdExecuteCommands = 64,
|
||||
VKB_CMD_vkCmdFillBuffer = 65,
|
||||
VKB_CMD_vkCmdNextSubpass = 66,
|
||||
VKB_CMD_vkCmdNextSubpass2 = 67,
|
||||
VKB_CMD_vkCmdPipelineBarrier = 68,
|
||||
VKB_CMD_vkCmdPipelineBarrier2 = 69,
|
||||
VKB_CMD_vkCmdPushConstants = 70,
|
||||
VKB_CMD_vkCmdPushConstants2 = 71,
|
||||
VKB_CMD_vkCmdPushDescriptorSet = 72,
|
||||
VKB_CMD_vkCmdPushDescriptorSet2 = 73,
|
||||
VKB_CMD_vkCmdResetEvent = 74,
|
||||
VKB_CMD_vkCmdResetEvent2 = 75,
|
||||
VKB_CMD_vkCmdResetQueryPool = 76,
|
||||
VKB_CMD_vkCmdResolveImage = 77,
|
||||
VKB_CMD_vkCmdResolveImage2 = 78,
|
||||
VKB_CMD_vkCmdSetAlphaToCoverageEnableEXT = 79,
|
||||
VKB_CMD_vkCmdSetAlphaToOneEnableEXT = 80,
|
||||
VKB_CMD_vkCmdSetAttachmentFeedbackLoopEnableEXT = 81,
|
||||
VKB_CMD_vkCmdSetBlendConstants = 82,
|
||||
VKB_CMD_vkCmdSetColorBlendAdvancedEXT = 83,
|
||||
VKB_CMD_vkCmdSetColorBlendEnableEXT = 84,
|
||||
VKB_CMD_vkCmdSetColorBlendEquationEXT = 85,
|
||||
VKB_CMD_vkCmdSetColorWriteEnableEXT = 86,
|
||||
VKB_CMD_vkCmdSetColorWriteMaskEXT = 87,
|
||||
VKB_CMD_vkCmdSetConservativeRasterizationModeEXT = 88,
|
||||
VKB_CMD_vkCmdSetCullMode = 89,
|
||||
VKB_CMD_vkCmdSetDepthBias = 90,
|
||||
VKB_CMD_vkCmdSetDepthBias2EXT = 91,
|
||||
VKB_CMD_vkCmdSetDepthBiasEnable = 92,
|
||||
VKB_CMD_vkCmdSetDepthBounds = 93,
|
||||
VKB_CMD_vkCmdSetDepthBoundsTestEnable = 94,
|
||||
VKB_CMD_vkCmdSetDepthClampEnableEXT = 95,
|
||||
VKB_CMD_vkCmdSetDepthClampRangeEXT = 96,
|
||||
VKB_CMD_vkCmdSetDepthClipEnableEXT = 97,
|
||||
VKB_CMD_vkCmdSetDepthClipNegativeOneToOneEXT = 98,
|
||||
VKB_CMD_vkCmdSetDepthCompareOp = 99,
|
||||
VKB_CMD_vkCmdSetDepthTestEnable = 100,
|
||||
VKB_CMD_vkCmdSetDepthWriteEnable = 101,
|
||||
VKB_CMD_vkCmdSetDeviceMask = 102,
|
||||
VKB_CMD_vkCmdSetDiscardRectangleEXT = 103,
|
||||
VKB_CMD_vkCmdSetDiscardRectangleEnableEXT = 104,
|
||||
VKB_CMD_vkCmdSetDiscardRectangleModeEXT = 105,
|
||||
VKB_CMD_vkCmdSetEvent = 106,
|
||||
VKB_CMD_vkCmdSetEvent2 = 107,
|
||||
VKB_CMD_vkCmdSetExtraPrimitiveOverestimationSizeEXT = 108,
|
||||
VKB_CMD_vkCmdSetFragmentShadingRateKHR = 109,
|
||||
VKB_CMD_vkCmdSetFrontFace = 110,
|
||||
VKB_CMD_vkCmdSetLineRasterizationModeEXT = 111,
|
||||
VKB_CMD_vkCmdSetLineStipple = 112,
|
||||
VKB_CMD_vkCmdSetLineStippleEnableEXT = 113,
|
||||
VKB_CMD_vkCmdSetLineWidth = 114,
|
||||
VKB_CMD_vkCmdSetLogicOpEXT = 115,
|
||||
VKB_CMD_vkCmdSetLogicOpEnableEXT = 116,
|
||||
VKB_CMD_vkCmdSetPatchControlPointsEXT = 117,
|
||||
VKB_CMD_vkCmdSetPolygonModeEXT = 118,
|
||||
VKB_CMD_vkCmdSetPrimitiveRestartEnable = 119,
|
||||
VKB_CMD_vkCmdSetPrimitiveTopology = 120,
|
||||
VKB_CMD_vkCmdSetProvokingVertexModeEXT = 121,
|
||||
VKB_CMD_vkCmdSetRasterizationSamplesEXT = 122,
|
||||
VKB_CMD_vkCmdSetRasterizationStreamEXT = 123,
|
||||
VKB_CMD_vkCmdSetRasterizerDiscardEnable = 124,
|
||||
VKB_CMD_vkCmdSetRenderingAttachmentLocations = 125,
|
||||
VKB_CMD_vkCmdSetRenderingInputAttachmentIndices = 126,
|
||||
VKB_CMD_vkCmdSetSampleLocationsEXT = 127,
|
||||
VKB_CMD_vkCmdSetSampleLocationsEnableEXT = 128,
|
||||
VKB_CMD_vkCmdSetSampleMaskEXT = 129,
|
||||
VKB_CMD_vkCmdSetScissor = 130,
|
||||
VKB_CMD_vkCmdSetScissorWithCount = 131,
|
||||
VKB_CMD_vkCmdSetStencilCompareMask = 132,
|
||||
VKB_CMD_vkCmdSetStencilOp = 133,
|
||||
VKB_CMD_vkCmdSetStencilReference = 134,
|
||||
VKB_CMD_vkCmdSetStencilTestEnable = 135,
|
||||
VKB_CMD_vkCmdSetStencilWriteMask = 136,
|
||||
VKB_CMD_vkCmdSetTessellationDomainOriginEXT = 137,
|
||||
VKB_CMD_vkCmdSetVertexInputEXT = 138,
|
||||
VKB_CMD_vkCmdSetViewport = 139,
|
||||
VKB_CMD_vkCmdSetViewportWithCount = 140,
|
||||
VKB_CMD_vkCmdUpdateBuffer = 141,
|
||||
VKB_CMD_vkCmdWaitEvents = 142,
|
||||
VKB_CMD_vkCmdWaitEvents2 = 143,
|
||||
VKB_CMD_vkCmdWriteTimestamp = 144,
|
||||
VKB_CMD_vkCmdWriteTimestamp2 = 145,
|
||||
VKB_CMD_vkCreateBuffer = 146,
|
||||
VKB_CMD_vkCreateBufferView = 147,
|
||||
VKB_CMD_vkCreateCommandPool = 148,
|
||||
VKB_CMD_vkCreateComputePipelines = 149,
|
||||
VKB_CMD_vkCreateDescriptorPool = 150,
|
||||
VKB_CMD_vkCreateDescriptorSetLayout = 151,
|
||||
VKB_CMD_vkCreateDescriptorUpdateTemplate = 152,
|
||||
VKB_CMD_vkCreateDevice = 153,
|
||||
VKB_CMD_vkCreateEvent = 154,
|
||||
VKB_CMD_vkCreateFence = 155,
|
||||
VKB_CMD_vkCreateFramebuffer = 156,
|
||||
VKB_CMD_vkCreateGraphicsPipelines = 157,
|
||||
VKB_CMD_vkCreateImage = 158,
|
||||
VKB_CMD_vkCreateImageView = 159,
|
||||
VKB_CMD_vkCreateInstance = 160,
|
||||
VKB_CMD_vkCreatePipelineCache = 161,
|
||||
VKB_CMD_vkCreatePipelineLayout = 162,
|
||||
VKB_CMD_vkCreateQueryPool = 163,
|
||||
VKB_CMD_vkCreateRenderPass = 164,
|
||||
VKB_CMD_vkCreateRenderPass2 = 165,
|
||||
VKB_CMD_vkCreateSampler = 166,
|
||||
VKB_CMD_vkCreateSamplerYcbcrConversion = 167,
|
||||
VKB_CMD_vkCreateSemaphore = 168,
|
||||
VKB_CMD_vkCreateShaderModule = 169,
|
||||
VKB_CMD_vkCreateTensorARM = 170,
|
||||
VKB_CMD_vkCreateTensorViewARM = 171,
|
||||
VKB_CMD_vkDestroyBuffer = 172,
|
||||
VKB_CMD_vkDestroyBufferView = 173,
|
||||
VKB_CMD_vkDestroyCommandPool = 174,
|
||||
VKB_CMD_vkDestroyDescriptorPool = 175,
|
||||
VKB_CMD_vkDestroyDescriptorSetLayout = 176,
|
||||
VKB_CMD_vkDestroyDescriptorUpdateTemplate = 177,
|
||||
VKB_CMD_vkDestroyDevice = 178,
|
||||
VKB_CMD_vkDestroyEvent = 179,
|
||||
VKB_CMD_vkDestroyFence = 180,
|
||||
VKB_CMD_vkDestroyFramebuffer = 181,
|
||||
VKB_CMD_vkDestroyImage = 182,
|
||||
VKB_CMD_vkDestroyImageView = 183,
|
||||
VKB_CMD_vkDestroyInstance = 184,
|
||||
VKB_CMD_vkDestroyPipeline = 185,
|
||||
VKB_CMD_vkDestroyPipelineCache = 186,
|
||||
VKB_CMD_vkDestroyPipelineLayout = 187,
|
||||
VKB_CMD_vkDestroyQueryPool = 188,
|
||||
VKB_CMD_vkDestroyRenderPass = 189,
|
||||
VKB_CMD_vkDestroySampler = 190,
|
||||
VKB_CMD_vkDestroySamplerYcbcrConversion = 191,
|
||||
VKB_CMD_vkDestroySemaphore = 192,
|
||||
VKB_CMD_vkDestroyShaderModule = 193,
|
||||
VKB_CMD_vkDestroyTensorARM = 194,
|
||||
VKB_CMD_vkDestroyTensorViewARM = 195,
|
||||
VKB_CMD_vkDeviceWaitIdle = 196,
|
||||
VKB_CMD_vkEndCommandBuffer = 197,
|
||||
VKB_CMD_vkEnumerateDeviceExtensionProperties = 198,
|
||||
VKB_CMD_vkEnumerateInstanceExtensionProperties = 199,
|
||||
VKB_CMD_vkEnumerateInstanceLayerProperties = 200,
|
||||
VKB_CMD_vkEnumerateInstanceVersion = 201,
|
||||
VKB_CMD_vkEnumeratePhysicalDeviceGroups = 202,
|
||||
VKB_CMD_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = 203,
|
||||
VKB_CMD_vkEnumeratePhysicalDevices = 204,
|
||||
VKB_CMD_vkFlushMappedMemoryRanges = 205,
|
||||
VKB_CMD_vkFreeCommandBuffers = 206,
|
||||
VKB_CMD_vkFreeDescriptorSets = 207,
|
||||
VKB_CMD_vkFreeMemory = 208,
|
||||
VKB_CMD_vkGetBufferDeviceAddress = 209,
|
||||
VKB_CMD_vkGetBufferMemoryRequirements = 210,
|
||||
VKB_CMD_vkGetBufferMemoryRequirements2 = 211,
|
||||
VKB_CMD_vkGetBufferOpaqueCaptureAddress = 212,
|
||||
VKB_CMD_vkGetCalibratedTimestampsKHR = 213,
|
||||
VKB_CMD_vkGetDescriptorSetLayoutSupport = 214,
|
||||
VKB_CMD_vkGetDeviceBufferMemoryRequirements = 215,
|
||||
VKB_CMD_vkGetDeviceGroupPeerMemoryFeatures = 216,
|
||||
VKB_CMD_vkGetDeviceImageMemoryRequirements = 217,
|
||||
VKB_CMD_vkGetDeviceImageSparseMemoryRequirements = 218,
|
||||
VKB_CMD_vkGetDeviceImageSubresourceLayout = 219,
|
||||
VKB_CMD_vkGetDeviceMemoryCommitment = 220,
|
||||
VKB_CMD_vkGetDeviceMemoryOpaqueCaptureAddress = 221,
|
||||
VKB_CMD_vkGetDeviceQueue = 222,
|
||||
VKB_CMD_vkGetDeviceQueue2 = 223,
|
||||
VKB_CMD_vkGetDeviceTensorMemoryRequirementsARM = 224,
|
||||
VKB_CMD_vkGetEventStatus = 225,
|
||||
VKB_CMD_vkGetFenceFdKHR = 226,
|
||||
VKB_CMD_vkGetFenceStatus = 227,
|
||||
VKB_CMD_vkGetImageDrmFormatModifierPropertiesEXT = 228,
|
||||
VKB_CMD_vkGetImageMemoryRequirements = 229,
|
||||
VKB_CMD_vkGetImageMemoryRequirements2 = 230,
|
||||
VKB_CMD_vkGetImageSparseMemoryRequirements = 231,
|
||||
VKB_CMD_vkGetImageSparseMemoryRequirements2 = 232,
|
||||
VKB_CMD_vkGetImageSubresourceLayout = 233,
|
||||
VKB_CMD_vkGetImageSubresourceLayout2 = 234,
|
||||
VKB_CMD_vkGetMemoryFdKHR = 235,
|
||||
VKB_CMD_vkGetMemoryFdPropertiesKHR = 236,
|
||||
VKB_CMD_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 237,
|
||||
VKB_CMD_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 238,
|
||||
VKB_CMD_vkGetPhysicalDeviceExternalBufferProperties = 239,
|
||||
VKB_CMD_vkGetPhysicalDeviceExternalFenceProperties = 240,
|
||||
VKB_CMD_vkGetPhysicalDeviceExternalSemaphoreProperties = 241,
|
||||
VKB_CMD_vkGetPhysicalDeviceExternalTensorPropertiesARM = 242,
|
||||
VKB_CMD_vkGetPhysicalDeviceFeatures = 243,
|
||||
VKB_CMD_vkGetPhysicalDeviceFeatures2 = 244,
|
||||
VKB_CMD_vkGetPhysicalDeviceFormatProperties = 245,
|
||||
VKB_CMD_vkGetPhysicalDeviceFormatProperties2 = 246,
|
||||
VKB_CMD_vkGetPhysicalDeviceFragmentShadingRatesKHR = 247,
|
||||
VKB_CMD_vkGetPhysicalDeviceImageFormatProperties = 248,
|
||||
VKB_CMD_vkGetPhysicalDeviceImageFormatProperties2 = 249,
|
||||
VKB_CMD_vkGetPhysicalDeviceMemoryProperties = 250,
|
||||
VKB_CMD_vkGetPhysicalDeviceMemoryProperties2 = 251,
|
||||
VKB_CMD_vkGetPhysicalDeviceMultisamplePropertiesEXT = 252,
|
||||
VKB_CMD_vkGetPhysicalDeviceProperties = 253,
|
||||
VKB_CMD_vkGetPhysicalDeviceProperties2 = 254,
|
||||
VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties = 255,
|
||||
VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties2 = 256,
|
||||
VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties = 257,
|
||||
VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties2 = 258,
|
||||
VKB_CMD_vkGetPhysicalDeviceToolProperties = 259,
|
||||
VKB_CMD_vkGetPipelineCacheData = 260,
|
||||
VKB_CMD_vkGetQueryPoolResults = 261,
|
||||
VKB_CMD_vkGetRenderAreaGranularity = 262,
|
||||
VKB_CMD_vkGetRenderingAreaGranularity = 263,
|
||||
VKB_CMD_vkGetSemaphoreCounterValue = 264,
|
||||
VKB_CMD_vkGetSemaphoreFdKHR = 265,
|
||||
VKB_CMD_vkGetShaderModuleCreateInfoIdentifierEXT = 266,
|
||||
VKB_CMD_vkGetShaderModuleIdentifierEXT = 267,
|
||||
VKB_CMD_vkGetTensorMemoryRequirementsARM = 268,
|
||||
VKB_CMD_vkImportFenceFdKHR = 269,
|
||||
VKB_CMD_vkImportSemaphoreFdKHR = 270,
|
||||
VKB_CMD_vkInvalidateMappedMemoryRanges = 271,
|
||||
VKB_CMD_vkMergePipelineCaches = 272,
|
||||
VKB_CMD_vkQueueBindSparse = 273,
|
||||
VKB_CMD_vkQueueSubmit = 274,
|
||||
VKB_CMD_vkQueueSubmit2 = 275,
|
||||
VKB_CMD_vkQueueWaitIdle = 276,
|
||||
VKB_CMD_vkResetCommandBuffer = 277,
|
||||
VKB_CMD_vkResetCommandPool = 278,
|
||||
VKB_CMD_vkResetDescriptorPool = 279,
|
||||
VKB_CMD_vkResetEvent = 280,
|
||||
VKB_CMD_vkResetFences = 281,
|
||||
VKB_CMD_vkResetQueryPool = 282,
|
||||
VKB_CMD_vkSetDeviceMemoryPriorityEXT = 283,
|
||||
VKB_CMD_vkSetEvent = 284,
|
||||
VKB_CMD_vkSignalSemaphore = 285,
|
||||
VKB_CMD_vkTrimCommandPool = 286,
|
||||
VKB_CMD_vkUpdateDescriptorSets = 287,
|
||||
VKB_CMD_vkWaitForFences = 288,
|
||||
VKB_CMD_vkWaitSemaphores = 289,
|
||||
VKB_CMD_COUNT = 290
|
||||
VKB_CMD_vkbAllocDescSets = 4,
|
||||
VKB_CMD_vkAllocateCommandBuffers = 5,
|
||||
VKB_CMD_vkAllocateDescriptorSets = 6,
|
||||
VKB_CMD_vkAllocateMemory = 7,
|
||||
VKB_CMD_vkBeginCommandBuffer = 8,
|
||||
VKB_CMD_vkBindBufferMemory = 9,
|
||||
VKB_CMD_vkBindBufferMemory2 = 10,
|
||||
VKB_CMD_vkBindImageMemory = 11,
|
||||
VKB_CMD_vkBindImageMemory2 = 12,
|
||||
VKB_CMD_vkBindTensorMemoryARM = 13,
|
||||
VKB_CMD_vkCmdBeginConditionalRenderingEXT = 14,
|
||||
VKB_CMD_vkCmdBeginCustomResolveEXT = 15,
|
||||
VKB_CMD_vkCmdBeginQuery = 16,
|
||||
VKB_CMD_vkCmdBeginQueryIndexedEXT = 17,
|
||||
VKB_CMD_vkCmdBeginRenderPass = 18,
|
||||
VKB_CMD_vkCmdBeginRenderPass2 = 19,
|
||||
VKB_CMD_vkCmdBeginRendering = 20,
|
||||
VKB_CMD_vkCmdBeginTransformFeedbackEXT = 21,
|
||||
VKB_CMD_vkCmdBindDescriptorSets = 22,
|
||||
VKB_CMD_vkCmdBindDescriptorSets2 = 23,
|
||||
VKB_CMD_vkCmdBindIndexBuffer = 24,
|
||||
VKB_CMD_vkCmdBindIndexBuffer2 = 25,
|
||||
VKB_CMD_vkCmdBindPipeline = 26,
|
||||
VKB_CMD_vkCmdBindTransformFeedbackBuffersEXT = 27,
|
||||
VKB_CMD_vkCmdBindVertexBuffers = 28,
|
||||
VKB_CMD_vkCmdBindVertexBuffers2 = 29,
|
||||
VKB_CMD_vkCmdBlitImage = 30,
|
||||
VKB_CMD_vkCmdBlitImage2 = 31,
|
||||
VKB_CMD_vkCmdClearAttachments = 32,
|
||||
VKB_CMD_vkCmdClearColorImage = 33,
|
||||
VKB_CMD_vkCmdClearDepthStencilImage = 34,
|
||||
VKB_CMD_vkCmdCopyBuffer = 35,
|
||||
VKB_CMD_vkCmdCopyBuffer2 = 36,
|
||||
VKB_CMD_vkCmdCopyBufferToImage = 37,
|
||||
VKB_CMD_vkCmdCopyBufferToImage2 = 38,
|
||||
VKB_CMD_vkCmdCopyImage = 39,
|
||||
VKB_CMD_vkCmdCopyImage2 = 40,
|
||||
VKB_CMD_vkCmdCopyImageToBuffer = 41,
|
||||
VKB_CMD_vkCmdCopyImageToBuffer2 = 42,
|
||||
VKB_CMD_vkCmdCopyQueryPoolResults = 43,
|
||||
VKB_CMD_vkCmdCopyTensorARM = 44,
|
||||
VKB_CMD_vkCmdDispatch = 45,
|
||||
VKB_CMD_vkCmdDispatchBase = 46,
|
||||
VKB_CMD_vkCmdDispatchIndirect = 47,
|
||||
VKB_CMD_vkCmdDraw = 48,
|
||||
VKB_CMD_vkCmdDrawIndexed = 49,
|
||||
VKB_CMD_vkCmdDrawIndexedIndirect = 50,
|
||||
VKB_CMD_vkCmdDrawIndexedIndirectCount = 51,
|
||||
VKB_CMD_vkCmdDrawIndirect = 52,
|
||||
VKB_CMD_vkCmdDrawIndirectByteCountEXT = 53,
|
||||
VKB_CMD_vkCmdDrawIndirectCount = 54,
|
||||
VKB_CMD_vkCmdDrawMultiEXT = 55,
|
||||
VKB_CMD_vkCmdDrawMultiIndexedEXT = 56,
|
||||
VKB_CMD_vkCmdEndConditionalRenderingEXT = 57,
|
||||
VKB_CMD_vkCmdEndQuery = 58,
|
||||
VKB_CMD_vkCmdEndQueryIndexedEXT = 59,
|
||||
VKB_CMD_vkCmdEndRenderPass = 60,
|
||||
VKB_CMD_vkCmdEndRenderPass2 = 61,
|
||||
VKB_CMD_vkCmdEndRendering = 62,
|
||||
VKB_CMD_vkCmdEndRendering2KHR = 63,
|
||||
VKB_CMD_vkCmdEndTransformFeedbackEXT = 64,
|
||||
VKB_CMD_vkCmdExecuteCommands = 65,
|
||||
VKB_CMD_vkCmdFillBuffer = 66,
|
||||
VKB_CMD_vkCmdNextSubpass = 67,
|
||||
VKB_CMD_vkCmdNextSubpass2 = 68,
|
||||
VKB_CMD_vkCmdPipelineBarrier = 69,
|
||||
VKB_CMD_vkCmdPipelineBarrier2 = 70,
|
||||
VKB_CMD_vkCmdPushConstants = 71,
|
||||
VKB_CMD_vkCmdPushConstants2 = 72,
|
||||
VKB_CMD_vkCmdPushDescriptorSet = 73,
|
||||
VKB_CMD_vkCmdPushDescriptorSet2 = 74,
|
||||
VKB_CMD_vkCmdResetEvent = 75,
|
||||
VKB_CMD_vkCmdResetEvent2 = 76,
|
||||
VKB_CMD_vkCmdResetQueryPool = 77,
|
||||
VKB_CMD_vkCmdResolveImage = 78,
|
||||
VKB_CMD_vkCmdResolveImage2 = 79,
|
||||
VKB_CMD_vkCmdSetAlphaToCoverageEnableEXT = 80,
|
||||
VKB_CMD_vkCmdSetAlphaToOneEnableEXT = 81,
|
||||
VKB_CMD_vkCmdSetAttachmentFeedbackLoopEnableEXT = 82,
|
||||
VKB_CMD_vkCmdSetBlendConstants = 83,
|
||||
VKB_CMD_vkCmdSetColorBlendAdvancedEXT = 84,
|
||||
VKB_CMD_vkCmdSetColorBlendEnableEXT = 85,
|
||||
VKB_CMD_vkCmdSetColorBlendEquationEXT = 86,
|
||||
VKB_CMD_vkCmdSetColorWriteEnableEXT = 87,
|
||||
VKB_CMD_vkCmdSetColorWriteMaskEXT = 88,
|
||||
VKB_CMD_vkCmdSetConservativeRasterizationModeEXT = 89,
|
||||
VKB_CMD_vkCmdSetCullMode = 90,
|
||||
VKB_CMD_vkCmdSetDepthBias = 91,
|
||||
VKB_CMD_vkCmdSetDepthBias2EXT = 92,
|
||||
VKB_CMD_vkCmdSetDepthBiasEnable = 93,
|
||||
VKB_CMD_vkCmdSetDepthBounds = 94,
|
||||
VKB_CMD_vkCmdSetDepthBoundsTestEnable = 95,
|
||||
VKB_CMD_vkCmdSetDepthClampEnableEXT = 96,
|
||||
VKB_CMD_vkCmdSetDepthClampRangeEXT = 97,
|
||||
VKB_CMD_vkCmdSetDepthClipEnableEXT = 98,
|
||||
VKB_CMD_vkCmdSetDepthClipNegativeOneToOneEXT = 99,
|
||||
VKB_CMD_vkCmdSetDepthCompareOp = 100,
|
||||
VKB_CMD_vkCmdSetDepthTestEnable = 101,
|
||||
VKB_CMD_vkCmdSetDepthWriteEnable = 102,
|
||||
VKB_CMD_vkCmdSetDeviceMask = 103,
|
||||
VKB_CMD_vkCmdSetDiscardRectangleEXT = 104,
|
||||
VKB_CMD_vkCmdSetDiscardRectangleEnableEXT = 105,
|
||||
VKB_CMD_vkCmdSetDiscardRectangleModeEXT = 106,
|
||||
VKB_CMD_vkCmdSetEvent = 107,
|
||||
VKB_CMD_vkCmdSetEvent2 = 108,
|
||||
VKB_CMD_vkCmdSetExtraPrimitiveOverestimationSizeEXT = 109,
|
||||
VKB_CMD_vkCmdSetFragmentShadingRateKHR = 110,
|
||||
VKB_CMD_vkCmdSetFrontFace = 111,
|
||||
VKB_CMD_vkCmdSetLineRasterizationModeEXT = 112,
|
||||
VKB_CMD_vkCmdSetLineStipple = 113,
|
||||
VKB_CMD_vkCmdSetLineStippleEnableEXT = 114,
|
||||
VKB_CMD_vkCmdSetLineWidth = 115,
|
||||
VKB_CMD_vkCmdSetLogicOpEXT = 116,
|
||||
VKB_CMD_vkCmdSetLogicOpEnableEXT = 117,
|
||||
VKB_CMD_vkCmdSetPatchControlPointsEXT = 118,
|
||||
VKB_CMD_vkCmdSetPolygonModeEXT = 119,
|
||||
VKB_CMD_vkCmdSetPrimitiveRestartEnable = 120,
|
||||
VKB_CMD_vkCmdSetPrimitiveTopology = 121,
|
||||
VKB_CMD_vkCmdSetProvokingVertexModeEXT = 122,
|
||||
VKB_CMD_vkCmdSetRasterizationSamplesEXT = 123,
|
||||
VKB_CMD_vkCmdSetRasterizationStreamEXT = 124,
|
||||
VKB_CMD_vkCmdSetRasterizerDiscardEnable = 125,
|
||||
VKB_CMD_vkCmdSetRenderingAttachmentLocations = 126,
|
||||
VKB_CMD_vkCmdSetRenderingInputAttachmentIndices = 127,
|
||||
VKB_CMD_vkCmdSetSampleLocationsEXT = 128,
|
||||
VKB_CMD_vkCmdSetSampleLocationsEnableEXT = 129,
|
||||
VKB_CMD_vkCmdSetSampleMaskEXT = 130,
|
||||
VKB_CMD_vkCmdSetScissor = 131,
|
||||
VKB_CMD_vkCmdSetScissorWithCount = 132,
|
||||
VKB_CMD_vkCmdSetStencilCompareMask = 133,
|
||||
VKB_CMD_vkCmdSetStencilOp = 134,
|
||||
VKB_CMD_vkCmdSetStencilReference = 135,
|
||||
VKB_CMD_vkCmdSetStencilTestEnable = 136,
|
||||
VKB_CMD_vkCmdSetStencilWriteMask = 137,
|
||||
VKB_CMD_vkCmdSetTessellationDomainOriginEXT = 138,
|
||||
VKB_CMD_vkCmdSetVertexInputEXT = 139,
|
||||
VKB_CMD_vkCmdSetViewport = 140,
|
||||
VKB_CMD_vkCmdSetViewportWithCount = 141,
|
||||
VKB_CMD_vkCmdUpdateBuffer = 142,
|
||||
VKB_CMD_vkCmdWaitEvents = 143,
|
||||
VKB_CMD_vkCmdWaitEvents2 = 144,
|
||||
VKB_CMD_vkCmdWriteTimestamp = 145,
|
||||
VKB_CMD_vkCmdWriteTimestamp2 = 146,
|
||||
VKB_CMD_vkCreateBuffer = 147,
|
||||
VKB_CMD_vkCreateBufferView = 148,
|
||||
VKB_CMD_vkCreateCommandPool = 149,
|
||||
VKB_CMD_vkCreateComputePipelines = 150,
|
||||
VKB_CMD_vkCreateDescriptorPool = 151,
|
||||
VKB_CMD_vkCreateDescriptorSetLayout = 152,
|
||||
VKB_CMD_vkCreateDescriptorUpdateTemplate = 153,
|
||||
VKB_CMD_vkCreateDevice = 154,
|
||||
VKB_CMD_vkCreateEvent = 155,
|
||||
VKB_CMD_vkCreateFence = 156,
|
||||
VKB_CMD_vkCreateFramebuffer = 157,
|
||||
VKB_CMD_vkCreateGraphicsPipelines = 158,
|
||||
VKB_CMD_vkCreateImage = 159,
|
||||
VKB_CMD_vkCreateImageView = 160,
|
||||
VKB_CMD_vkCreateInstance = 161,
|
||||
VKB_CMD_vkCreatePipelineCache = 162,
|
||||
VKB_CMD_vkCreatePipelineLayout = 163,
|
||||
VKB_CMD_vkCreateQueryPool = 164,
|
||||
VKB_CMD_vkCreateRenderPass = 165,
|
||||
VKB_CMD_vkCreateRenderPass2 = 166,
|
||||
VKB_CMD_vkCreateSampler = 167,
|
||||
VKB_CMD_vkCreateSamplerYcbcrConversion = 168,
|
||||
VKB_CMD_vkCreateSemaphore = 169,
|
||||
VKB_CMD_vkCreateShaderModule = 170,
|
||||
VKB_CMD_vkCreateTensorARM = 171,
|
||||
VKB_CMD_vkCreateTensorViewARM = 172,
|
||||
VKB_CMD_vkDestroyBuffer = 173,
|
||||
VKB_CMD_vkDestroyBufferView = 174,
|
||||
VKB_CMD_vkDestroyCommandPool = 175,
|
||||
VKB_CMD_vkDestroyDescriptorPool = 176,
|
||||
VKB_CMD_vkDestroyDescriptorSetLayout = 177,
|
||||
VKB_CMD_vkDestroyDescriptorUpdateTemplate = 178,
|
||||
VKB_CMD_vkDestroyDevice = 179,
|
||||
VKB_CMD_vkDestroyEvent = 180,
|
||||
VKB_CMD_vkDestroyFence = 181,
|
||||
VKB_CMD_vkDestroyFramebuffer = 182,
|
||||
VKB_CMD_vkDestroyImage = 183,
|
||||
VKB_CMD_vkDestroyImageView = 184,
|
||||
VKB_CMD_vkDestroyInstance = 185,
|
||||
VKB_CMD_vkDestroyPipeline = 186,
|
||||
VKB_CMD_vkDestroyPipelineCache = 187,
|
||||
VKB_CMD_vkDestroyPipelineLayout = 188,
|
||||
VKB_CMD_vkDestroyQueryPool = 189,
|
||||
VKB_CMD_vkDestroyRenderPass = 190,
|
||||
VKB_CMD_vkDestroySampler = 191,
|
||||
VKB_CMD_vkDestroySamplerYcbcrConversion = 192,
|
||||
VKB_CMD_vkDestroySemaphore = 193,
|
||||
VKB_CMD_vkDestroyShaderModule = 194,
|
||||
VKB_CMD_vkDestroyTensorARM = 195,
|
||||
VKB_CMD_vkDestroyTensorViewARM = 196,
|
||||
VKB_CMD_vkDeviceWaitIdle = 197,
|
||||
VKB_CMD_vkEndCommandBuffer = 198,
|
||||
VKB_CMD_vkEnumerateDeviceExtensionProperties = 199,
|
||||
VKB_CMD_vkEnumerateInstanceExtensionProperties = 200,
|
||||
VKB_CMD_vkEnumerateInstanceLayerProperties = 201,
|
||||
VKB_CMD_vkEnumerateInstanceVersion = 202,
|
||||
VKB_CMD_vkEnumeratePhysicalDeviceGroups = 203,
|
||||
VKB_CMD_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = 204,
|
||||
VKB_CMD_vkEnumeratePhysicalDevices = 205,
|
||||
VKB_CMD_vkFlushMappedMemoryRanges = 206,
|
||||
VKB_CMD_vkFreeCommandBuffers = 207,
|
||||
VKB_CMD_vkFreeDescriptorSets = 208,
|
||||
VKB_CMD_vkFreeMemory = 209,
|
||||
VKB_CMD_vkGetBufferDeviceAddress = 210,
|
||||
VKB_CMD_vkGetBufferMemoryRequirements = 211,
|
||||
VKB_CMD_vkGetBufferMemoryRequirements2 = 212,
|
||||
VKB_CMD_vkGetBufferOpaqueCaptureAddress = 213,
|
||||
VKB_CMD_vkGetCalibratedTimestampsKHR = 214,
|
||||
VKB_CMD_vkGetDescriptorSetLayoutSupport = 215,
|
||||
VKB_CMD_vkGetDeviceBufferMemoryRequirements = 216,
|
||||
VKB_CMD_vkGetDeviceGroupPeerMemoryFeatures = 217,
|
||||
VKB_CMD_vkGetDeviceImageMemoryRequirements = 218,
|
||||
VKB_CMD_vkGetDeviceImageSparseMemoryRequirements = 219,
|
||||
VKB_CMD_vkGetDeviceImageSubresourceLayout = 220,
|
||||
VKB_CMD_vkGetDeviceMemoryCommitment = 221,
|
||||
VKB_CMD_vkGetDeviceMemoryOpaqueCaptureAddress = 222,
|
||||
VKB_CMD_vkGetDeviceQueue = 223,
|
||||
VKB_CMD_vkGetDeviceQueue2 = 224,
|
||||
VKB_CMD_vkGetDeviceTensorMemoryRequirementsARM = 225,
|
||||
VKB_CMD_vkGetEventStatus = 226,
|
||||
VKB_CMD_vkGetFenceFdKHR = 227,
|
||||
VKB_CMD_vkGetFenceStatus = 228,
|
||||
VKB_CMD_vkGetImageDrmFormatModifierPropertiesEXT = 229,
|
||||
VKB_CMD_vkGetImageMemoryRequirements = 230,
|
||||
VKB_CMD_vkGetImageMemoryRequirements2 = 231,
|
||||
VKB_CMD_vkGetImageSparseMemoryRequirements = 232,
|
||||
VKB_CMD_vkGetImageSparseMemoryRequirements2 = 233,
|
||||
VKB_CMD_vkGetImageSubresourceLayout = 234,
|
||||
VKB_CMD_vkGetImageSubresourceLayout2 = 235,
|
||||
VKB_CMD_vkGetMemoryFdKHR = 236,
|
||||
VKB_CMD_vkGetMemoryFdPropertiesKHR = 237,
|
||||
VKB_CMD_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 238,
|
||||
VKB_CMD_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 239,
|
||||
VKB_CMD_vkGetPhysicalDeviceExternalBufferProperties = 240,
|
||||
VKB_CMD_vkGetPhysicalDeviceExternalFenceProperties = 241,
|
||||
VKB_CMD_vkGetPhysicalDeviceExternalSemaphoreProperties = 242,
|
||||
VKB_CMD_vkGetPhysicalDeviceExternalTensorPropertiesARM = 243,
|
||||
VKB_CMD_vkGetPhysicalDeviceFeatures = 244,
|
||||
VKB_CMD_vkGetPhysicalDeviceFeatures2 = 245,
|
||||
VKB_CMD_vkGetPhysicalDeviceFormatProperties = 246,
|
||||
VKB_CMD_vkGetPhysicalDeviceFormatProperties2 = 247,
|
||||
VKB_CMD_vkGetPhysicalDeviceFragmentShadingRatesKHR = 248,
|
||||
VKB_CMD_vkGetPhysicalDeviceImageFormatProperties = 249,
|
||||
VKB_CMD_vkGetPhysicalDeviceImageFormatProperties2 = 250,
|
||||
VKB_CMD_vkGetPhysicalDeviceMemoryProperties = 251,
|
||||
VKB_CMD_vkGetPhysicalDeviceMemoryProperties2 = 252,
|
||||
VKB_CMD_vkGetPhysicalDeviceMultisamplePropertiesEXT = 253,
|
||||
VKB_CMD_vkGetPhysicalDeviceProperties = 254,
|
||||
VKB_CMD_vkGetPhysicalDeviceProperties2 = 255,
|
||||
VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties = 256,
|
||||
VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties2 = 257,
|
||||
VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties = 258,
|
||||
VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties2 = 259,
|
||||
VKB_CMD_vkGetPhysicalDeviceToolProperties = 260,
|
||||
VKB_CMD_vkGetPipelineCacheData = 261,
|
||||
VKB_CMD_vkGetQueryPoolResults = 262,
|
||||
VKB_CMD_vkGetRenderAreaGranularity = 263,
|
||||
VKB_CMD_vkGetRenderingAreaGranularity = 264,
|
||||
VKB_CMD_vkGetSemaphoreCounterValue = 265,
|
||||
VKB_CMD_vkGetSemaphoreFdKHR = 266,
|
||||
VKB_CMD_vkGetShaderModuleCreateInfoIdentifierEXT = 267,
|
||||
VKB_CMD_vkGetShaderModuleIdentifierEXT = 268,
|
||||
VKB_CMD_vkGetTensorMemoryRequirementsARM = 269,
|
||||
VKB_CMD_vkImportFenceFdKHR = 270,
|
||||
VKB_CMD_vkImportSemaphoreFdKHR = 271,
|
||||
VKB_CMD_vkInvalidateMappedMemoryRanges = 272,
|
||||
VKB_CMD_vkMergePipelineCaches = 273,
|
||||
VKB_CMD_vkQueueBindSparse = 274,
|
||||
VKB_CMD_vkQueueSubmit = 275,
|
||||
VKB_CMD_vkQueueSubmit2 = 276,
|
||||
VKB_CMD_vkQueueWaitIdle = 277,
|
||||
VKB_CMD_vkResetCommandBuffer = 278,
|
||||
VKB_CMD_vkResetCommandPool = 279,
|
||||
VKB_CMD_vkResetDescriptorPool = 280,
|
||||
VKB_CMD_vkResetEvent = 281,
|
||||
VKB_CMD_vkResetFences = 282,
|
||||
VKB_CMD_vkResetQueryPool = 283,
|
||||
VKB_CMD_vkSetDeviceMemoryPriorityEXT = 284,
|
||||
VKB_CMD_vkSetEvent = 285,
|
||||
VKB_CMD_vkSignalSemaphore = 286,
|
||||
VKB_CMD_vkTrimCommandPool = 287,
|
||||
VKB_CMD_vkUpdateDescriptorSets = 288,
|
||||
VKB_CMD_vkWaitForFences = 289,
|
||||
VKB_CMD_vkWaitSemaphores = 290,
|
||||
VKB_CMD_COUNT = 291
|
||||
};
|
||||
extern const char *const vkb_cmd_names[VKB_CMD_COUNT];
|
||||
extern const unsigned char vkb_cmd_result[VKB_CMD_COUNT]; /* returns VkResult (first in the reply) */
|
||||
|
||||
@@ -7428,6 +7428,7 @@ const vkb_srv_handler vkb_srv_handlers[VKB_CMD_COUNT] = {
|
||||
[VKB_CMD_vkbQueryServer] = vkb_sv_vkbQueryServer,
|
||||
[VKB_CMD_vkbDescUpdateRaw] = vkb_sv_vkbDescUpdateRaw,
|
||||
[VKB_CMD_vkbPushDescRaw] = vkb_sv_vkbPushDescRaw,
|
||||
[VKB_CMD_vkbAllocDescSets] = vkb_sv_vkbAllocDescSets,
|
||||
[VKB_CMD_vkAllocateCommandBuffers] = vkb_sv_vkAllocateCommandBuffers,
|
||||
[VKB_CMD_vkAllocateDescriptorSets] = vkb_sv_vkAllocateDescriptorSets,
|
||||
[VKB_CMD_vkAllocateMemory] = vkb_sv_vkAllocateMemory,
|
||||
|
||||
@@ -15650,6 +15650,7 @@ const char *const vkb_cmd_names[VKB_CMD_COUNT] = {
|
||||
"vkbQueryServer",
|
||||
"vkbDescUpdateRaw",
|
||||
"vkbPushDescRaw",
|
||||
"vkbAllocDescSets",
|
||||
"vkAllocateCommandBuffers",
|
||||
"vkAllocateDescriptorSets",
|
||||
"vkAllocateMemory",
|
||||
@@ -15942,6 +15943,7 @@ const unsigned char vkb_cmd_result[VKB_CMD_COUNT] = {
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
|
||||
@@ -296,4 +296,5 @@ 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);
|
||||
void vkb_sv_vkbAllocDescSets(vkb_srv_call *c);
|
||||
#endif
|
||||
Reference in new issue
Block a user