feat(vkbridge): emulation layer + VK_KHR_maintenance5 for drivers without it

Zink (Mesa 26.2) and DXVK 2.7 refuse a Vulkan 1.3 device without maintenance5. The server
installs dispatch-table wrappers: flags2 folded into 32-bit flags, inline shader modules,
BindIndexBuffer2/area granularity/subresource layout 2, VK_REMAINING_ARRAY_LAYERS and
VK_WHOLE_SIZE resolved from tracked images/buffers. Host: Zink glxgears in gamescope at
144 fps with the driver's maintenance5 hidden and the API capped at 1.3.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KZqR8XUE8czvGzEpgSCVQR
This commit is contained in:
ahmadandClaude Opus 5.5 authored and Ahmad Sayed Alsayed Ebrahim committed 2026-10-10 14:28:13 +03:00
1 parent c3f02222fc
commit bf6dbb642a
7 files changed
+535 -23

No files matched your search

+22 -6
View File
@@ -11,6 +11,14 @@
#include <stdlib.h>
#include <string.h>
static int token(const char *list, const char *t)
{
size_t n = strlen(t);
for (const char *p = list; p && (p = strstr(p, t)); p += n)
if ((p == list || p[-1] == ',') && (p[n] == ',' || p[n] == 0)) return 1;
return 0;
}
static int env_off(const char *name)
{
const char *v = getenv(name);
@@ -25,24 +33,31 @@ uint32_t vkb_emu_detect(const vkb_dispatch *idt, VkPhysicalDevice pd)
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;
int divisor = 0, depth_clip = 0, maint5 = 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;
if (!strcmp(e[i].extensionName, "VK_KHR_maintenance5")) maint5 = 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;
if (token(fake, "bc")) f.textureCompressionBC = VK_FALSE;
if (token(fake, "divisor")) divisor = 0;
if (token(fake, "clip")) f.shaderClipDistance = VK_FALSE;
if (token(fake, "cull")) f.shaderCullDistance = VK_FALSE;
if (token(fake, "depthclip")) depth_clip = 0;
if (token(fake, "maint5")) maint5 = 0;
}
uint32_t emu = 0;
VkPhysicalDeviceProperties props;
idt->vkGetPhysicalDeviceProperties(pd, &props);
/* Vulkan 1.4 has maintenance5 in core. */
if (!maint5 && (props.apiVersion < VK_API_VERSION_1_4 || (fake && token(fake, "maint5"))) && !env_off("VKBRIDGE_EMU_MAINT5"))
emu |= VKB_EMU_MAINT5;
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;
@@ -87,6 +102,7 @@ void vkb_emu_device_create_info(vkb_srv_table *inst, VkPhysicalDevice pd, uint32
}
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);
if (emu & VKB_EMU_MAINT5) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES);
(void)a;
}
+44 -5
View File
@@ -5,20 +5,59 @@
#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
#define VKB_EMU_IMPLEMENTED (VKB_EMU_MAINT5)
#define VKB_EMU_BUCKETS 1024
typedef struct vkb_emu_image {
VkImage image;
VkImageType type;
VkFormat format; /* what the driver holds */
VkFormat client_format; /* what the app asked for (differs for emulated formats) */
VkExtent3D extent;
uint32_t mips, layers;
void *emu; /* per-emulation state (BCn: decode resources) */
struct vkb_emu_image *next;
} vkb_emu_image;
typedef struct vkb_emu_buffer {
VkBuffer buffer;
VkDeviceSize size;
struct vkb_emu_buffer *next;
} vkb_emu_buffer;
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_image *images[VKB_EMU_BUCKETS];
vkb_emu_buffer *buffers[VKB_EMU_BUCKETS];
void *bcn; /* server_emu_bcn.c */
void *shaders; /* server_emu_shader.c */
} vkb_emu_device;
/* layer (server_emu_layer.c) */
vkb_emu_device *vkb_emu_cur(void);
const vkb_dispatch *vkb_emu_real(void);
void *vkb_emu_chain_take(const void *head, VkStructureType t);
vkb_emu_image *vkb_emu_find_image(vkb_emu_device *e, VkImage img);
void vkb_emu_track_image(vkb_emu_device *e, VkImage img, const VkImageCreateInfo *ci, VkFormat client_format);
/* feature hooks (server_emu_features.c and friends) */
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);
void vkb_emu_install_features(vkb_srv_table *dev);
void vkb_emu_uninstall_features(vkb_srv_table *dev);
void vkb_emu_image_create_info(vkb_emu_device *e, VkImageCreateInfo *ci);
void vkb_emu_image_release(vkb_emu_device *e, vkb_emu_image *img);
void vkb_emu_graphics_pipeline_info(vkb_emu_device *e, VkGraphicsPipelineCreateInfo *ci);
/* 1 = handled (the emulation recorded its own commands instead). */
int vkb_emu_copy_image(vkb_emu_device *e, VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
uint32_t n, const VkImageCopy *regions);
int vkb_emu_copy_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyImageInfo2 *info);
int vkb_emu_copy_buffer_to_image(vkb_emu_device *e, VkCommandBuffer cb, VkBuffer src, VkImage dst, VkImageLayout dl, uint32_t n,
const VkBufferImageCopy *regions);
int vkb_emu_copy_buffer_to_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyBufferToImageInfo2 *info);
#endif
@@ -0,0 +1,31 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
*
* Hooks of the feature emulations that are not implemented yet: everything passes through.
*/
#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_features(vkb_srv_table *dev) { (void)dev; }
void vkb_emu_uninstall_features(vkb_srv_table *dev) { (void)dev; }
void vkb_emu_image_create_info(vkb_emu_device *e, VkImageCreateInfo *ci) { (void)e; (void)ci; }
void vkb_emu_image_release(vkb_emu_device *e, vkb_emu_image *img) { (void)e; (void)img; }
void vkb_emu_graphics_pipeline_info(vkb_emu_device *e, VkGraphicsPipelineCreateInfo *ci) { (void)e; (void)ci; }
int vkb_emu_copy_image(vkb_emu_device *e, VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
uint32_t n, const VkImageCopy *regions)
{
(void)e; (void)cb; (void)src; (void)sl; (void)dst; (void)dl; (void)n; (void)regions;
return 0;
}
int vkb_emu_copy_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyImageInfo2 *info) { (void)e; (void)cb; (void)info; return 0; }
int vkb_emu_copy_buffer_to_image(vkb_emu_device *e, VkCommandBuffer cb, VkBuffer src, VkImage dst, VkImageLayout dl, uint32_t n,
const VkBufferImageCopy *regions)
{
(void)e; (void)cb; (void)src; (void)dst; (void)dl; (void)n; (void)regions;
return 0;
}
int vkb_emu_copy_buffer_to_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyBufferToImageInfo2 *info)
{
(void)e; (void)cb; (void)info;
return 0;
}
+428 -7
View File
@@ -1,23 +1,444 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
*
* Emulation wrappers installed into a device's dispatch table.
* Emulation wrappers installed into a device's dispatch table, like a Vulkan layer: the generated
* handlers call c->dt, which for an emulating device points here first. The device is found
* through the per-call table the connection loop sets (vkb_srv_current_table).
*
* VK_KHR_maintenance5 (Zink and DXVK 2.7 refuse a Vulkan 1.3 device without it):
* - 64-bit flags structures (pipeline create flags 2, buffer usage 2) folded into the 32-bit
* fields, which hold every bit a 1.3 driver knows;
* - shader modules given inline (VkShaderModuleCreateInfo chained to a stage) created and
* destroyed around the pipeline;
* - vkCmdBindIndexBuffer2, vkGetRenderingAreaGranularity, vkGetImageSubresourceLayout2 and
* vkGetDeviceImageSubresourceLayout on their 1.0 equivalents;
* - VK_REMAINING_ARRAY_LAYERS in copy regions and VK_WHOLE_SIZE in vertex buffer sizes, resolved
* from the image/buffer the server keeps a record of.
*/
#define _GNU_SOURCE
#include "server_emu.h"
int vkb_emu_bcn_supported(const vkb_dispatch *idt, VkPhysicalDevice pd)
#include <stdlib.h>
#include <string.h>
/* ------------------------------------------------------------------ resource records */
static unsigned rh(uint64_t k)
{
(void)idt;
(void)pd;
return 0;
k ^= k >> 29;
k *= 0xbf58476d1ce4e5b9ull;
return (unsigned)(k >> 52) & (VKB_EMU_BUCKETS - 1);
}
void vkb_emu_track_image(vkb_emu_device *e, VkImage img, const VkImageCreateInfo *ci, VkFormat client_format)
{
vkb_emu_image *r = calloc(1, sizeof(*r));
r->image = img;
r->type = ci->imageType;
r->format = ci->format;
r->client_format = client_format;
r->extent = ci->extent;
r->mips = ci->mipLevels;
r->layers = ci->arrayLayers;
pthread_mutex_lock(&e->lock);
unsigned h = rh((uint64_t)img);
r->next = e->images[h];
e->images[h] = r;
pthread_mutex_unlock(&e->lock);
}
vkb_emu_image *vkb_emu_find_image(vkb_emu_device *e, VkImage img)
{
pthread_mutex_lock(&e->lock);
vkb_emu_image *r = e->images[rh((uint64_t)img)];
while (r && r->image != img) r = r->next;
pthread_mutex_unlock(&e->lock);
return r;
}
static void untrack_image(vkb_emu_device *e, VkImage img)
{
pthread_mutex_lock(&e->lock);
vkb_emu_image **pp = &e->images[rh((uint64_t)img)];
while (*pp && (*pp)->image != img) pp = &(*pp)->next;
vkb_emu_image *r = *pp;
if (r) *pp = r->next;
pthread_mutex_unlock(&e->lock);
if (r) {
vkb_emu_image_release(e, r);
free(r);
}
}
static void track_buffer(vkb_emu_device *e, VkBuffer b, VkDeviceSize size)
{
vkb_emu_buffer *r = calloc(1, sizeof(*r));
r->buffer = b;
r->size = size;
pthread_mutex_lock(&e->lock);
unsigned h = rh((uint64_t)b);
r->next = e->buffers[h];
e->buffers[h] = r;
pthread_mutex_unlock(&e->lock);
}
static VkDeviceSize buffer_size(vkb_emu_device *e, VkBuffer b)
{
pthread_mutex_lock(&e->lock);
vkb_emu_buffer *r = e->buffers[rh((uint64_t)b)];
while (r && r->buffer != b) r = r->next;
VkDeviceSize s = r ? r->size : 0;
pthread_mutex_unlock(&e->lock);
return s;
}
static void untrack_buffer(vkb_emu_device *e, VkBuffer b)
{
pthread_mutex_lock(&e->lock);
vkb_emu_buffer **pp = &e->buffers[rh((uint64_t)b)];
while (*pp && (*pp)->buffer != b) pp = &(*pp)->next;
vkb_emu_buffer *r = *pp;
if (r) *pp = r->next;
pthread_mutex_unlock(&e->lock);
free(r);
}
vkb_emu_device *vkb_emu_cur(void)
{
vkb_srv_table *t = vkb_srv_current_table();
return t ? t->emu : NULL;
}
const vkb_dispatch *vkb_emu_real(void)
{
return &vkb_srv_current_table()->real;
}
/* Removes the first structure of type t from a chain we own (decoded into the call's arena). */
void *vkb_emu_chain_take(const void *head_const, VkStructureType t)
{
VkBaseOutStructure *prev = (VkBaseOutStructure *)head_const;
while (prev->pNext) {
if (prev->pNext->sType == t) {
VkBaseOutStructure *found = prev->pNext;
prev->pNext = found->pNext;
return found;
}
prev = prev->pNext;
}
return NULL;
}
/* ------------------------------------------------------------------ resources */
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
{
vkb_emu_device *e = vkb_emu_cur();
VkBufferCreateInfo *ci = (VkBufferCreateInfo *)pCreateInfo;
if (e->flags & VKB_EMU_MAINT5) {
VkBufferUsageFlags2CreateInfo *u = vkb_emu_chain_take(ci, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO);
if (u) ci->usage = (VkBufferUsageFlags)u->usage;
}
VkResult r = vkb_emu_real()->vkCreateBuffer(device, ci, pAllocator, pBuffer);
if (r == VK_SUCCESS) track_buffer(e, *pBuffer, ci->size);
return r;
}
static VKAPI_ATTR void VKAPI_CALL emu_DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
{
if (buffer) untrack_buffer(vkb_emu_cur(), buffer);
vkb_emu_real()->vkDestroyBuffer(device, buffer, pAllocator);
}
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
{
if (vkb_emu_cur()->flags & VKB_EMU_MAINT5) vkb_emu_chain_take(pCreateInfo, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO);
return vkb_emu_real()->vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
}
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkImage *pImage)
{
vkb_emu_device *e = vkb_emu_cur();
VkImageCreateInfo *ci = (VkImageCreateInfo *)pCreateInfo;
VkFormat client_format = ci->format;
vkb_emu_image_create_info(e, ci);
VkResult r = vkb_emu_real()->vkCreateImage(device, ci, pAllocator, pImage);
if (r == VK_SUCCESS) vkb_emu_track_image(e, *pImage, ci, client_format);
return r;
}
static VKAPI_ATTR void VKAPI_CALL emu_DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
{
if (image) untrack_image(vkb_emu_cur(), image);
vkb_emu_real()->vkDestroyImage(device, image, pAllocator);
}
/* ------------------------------------------------------------------ pipelines */
/* Fold flags2 and create inline shader modules; temporaries are recorded in mods[]. */
static void prep_stage(VkDevice device, VkPipelineShaderStageCreateInfo *st, VkShaderModule *mods, uint32_t *nmods, uint32_t cap)
{
if (st->module) return;
VkShaderModuleCreateInfo *smci = vkb_emu_chain_take(st, VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO);
if (!smci) return;
VkShaderModule m = VK_NULL_HANDLE;
smci->pNext = NULL;
if (vkb_emu_real()->vkCreateShaderModule(device, smci, NULL, &m) == VK_SUCCESS) {
st->module = m;
if (*nmods < cap) mods[(*nmods)++] = m;
}
}
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateGraphicsPipelines(VkDevice device, VkPipelineCache cache, uint32_t n,
const VkGraphicsPipelineCreateInfo *infos,
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
{
vkb_emu_device *e = vkb_emu_cur();
VkShaderModule mods[64];
uint32_t nmods = 0;
for (uint32_t i = 0; i < n; i++) {
VkGraphicsPipelineCreateInfo *ci = (VkGraphicsPipelineCreateInfo *)&infos[i];
if (e->flags & VKB_EMU_MAINT5) {
VkPipelineCreateFlags2CreateInfo *f2 = vkb_emu_chain_take(ci, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
if (f2) ci->flags = (VkPipelineCreateFlags)f2->flags;
for (uint32_t s = 0; s < ci->stageCount; s++)
prep_stage(device, (VkPipelineShaderStageCreateInfo *)&ci->pStages[s], mods, &nmods, 64);
}
vkb_emu_graphics_pipeline_info(e, ci);
}
VkResult r = vkb_emu_real()->vkCreateGraphicsPipelines(device, cache, n, infos, pAllocator, pPipelines);
for (uint32_t i = 0; i < nmods; i++) vkb_emu_real()->vkDestroyShaderModule(device, mods[i], NULL);
return r;
}
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateComputePipelines(VkDevice device, VkPipelineCache cache, uint32_t n,
const VkComputePipelineCreateInfo *infos,
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
{
vkb_emu_device *e = vkb_emu_cur();
VkShaderModule mods[64];
uint32_t nmods = 0;
for (uint32_t i = 0; i < n; i++) {
VkComputePipelineCreateInfo *ci = (VkComputePipelineCreateInfo *)&infos[i];
if (e->flags & VKB_EMU_MAINT5) {
VkPipelineCreateFlags2CreateInfo *f2 = vkb_emu_chain_take(ci, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
if (f2) ci->flags = (VkPipelineCreateFlags)f2->flags;
prep_stage(device, &ci->stage, mods, &nmods, 64);
}
}
VkResult r = vkb_emu_real()->vkCreateComputePipelines(device, cache, n, infos, pAllocator, pPipelines);
for (uint32_t i = 0; i < nmods; i++) vkb_emu_real()->vkDestroyShaderModule(device, mods[i], NULL);
return r;
}
/* ------------------------------------------------------------------ maintenance5 entry points */
static VKAPI_ATTR void VKAPI_CALL emu_CmdBindIndexBuffer2(VkCommandBuffer cb, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size,
VkIndexType type)
{
(void)size;
vkb_emu_real()->vkCmdBindIndexBuffer(cb, buffer, offset, type);
}
static VKAPI_ATTR void VKAPI_CALL emu_GetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo *info, VkExtent2D *g)
{
(void)device;
(void)info;
g->width = 1;
g->height = 1;
}
static VKAPI_ATTR void VKAPI_CALL emu_GetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2 *sub,
VkSubresourceLayout2 *layout)
{
vkb_emu_real()->vkGetImageSubresourceLayout(device, image, &sub->imageSubresource, &layout->subresourceLayout);
}
static VKAPI_ATTR void VKAPI_CALL emu_GetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo *info,
VkSubresourceLayout2 *layout)
{
VkImage img;
memset(&layout->subresourceLayout, 0, sizeof(layout->subresourceLayout));
if (vkb_emu_real()->vkCreateImage(device, info->pCreateInfo, NULL, &img) != VK_SUCCESS) return;
vkb_emu_real()->vkGetImageSubresourceLayout(device, img, &info->pSubresource->imageSubresource, &layout->subresourceLayout);
vkb_emu_real()->vkDestroyImage(device, img, NULL);
}
/* VK_REMAINING_ARRAY_LAYERS in a copy region, resolved against the image. */
static void fix_layers(vkb_emu_device *e, VkImage img, VkImageSubresourceLayers *l)
{
if (l->layerCount != VK_REMAINING_ARRAY_LAYERS) return;
vkb_emu_image *r = vkb_emu_find_image(e, img);
l->layerCount = r && r->layers > l->baseArrayLayer ? r->layers - l->baseArrayLayer : 1;
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImage(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
uint32_t n, const VkImageCopy *regions)
{
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < n; i++) {
fix_layers(e, src, (VkImageSubresourceLayers *)&regions[i].srcSubresource);
fix_layers(e, dst, (VkImageSubresourceLayers *)&regions[i].dstSubresource);
}
if (vkb_emu_copy_image(e, cb, src, sl, dst, dl, n, regions)) return;
vkb_emu_real()->vkCmdCopyImage(cb, src, sl, dst, dl, n, regions);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImage2(VkCommandBuffer cb, const VkCopyImageInfo2 *info)
{
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < info->regionCount; i++) {
fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].srcSubresource);
fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].dstSubresource);
}
if (vkb_emu_copy_image2(e, cb, info)) return;
vkb_emu_real()->vkCmdCopyImage2(cb, info);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdBlitImage(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
uint32_t n, const VkImageBlit *regions, VkFilter filter)
{
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < n; i++) {
fix_layers(e, src, (VkImageSubresourceLayers *)&regions[i].srcSubresource);
fix_layers(e, dst, (VkImageSubresourceLayers *)&regions[i].dstSubresource);
}
vkb_emu_real()->vkCmdBlitImage(cb, src, sl, dst, dl, n, regions, filter);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdBlitImage2(VkCommandBuffer cb, const VkBlitImageInfo2 *info)
{
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < info->regionCount; i++) {
fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].srcSubresource);
fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].dstSubresource);
}
vkb_emu_real()->vkCmdBlitImage2(cb, info);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdResolveImage(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
uint32_t n, const VkImageResolve *regions)
{
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < n; i++) {
fix_layers(e, src, (VkImageSubresourceLayers *)&regions[i].srcSubresource);
fix_layers(e, dst, (VkImageSubresourceLayers *)&regions[i].dstSubresource);
}
vkb_emu_real()->vkCmdResolveImage(cb, src, sl, dst, dl, n, regions);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdResolveImage2(VkCommandBuffer cb, const VkResolveImageInfo2 *info)
{
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < info->regionCount; i++) {
fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].srcSubresource);
fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].dstSubresource);
}
vkb_emu_real()->vkCmdResolveImage2(cb, info);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyBufferToImage(VkCommandBuffer cb, VkBuffer src, VkImage dst, VkImageLayout dl, uint32_t n,
const VkBufferImageCopy *regions)
{
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < n; i++) fix_layers(e, dst, (VkImageSubresourceLayers *)&regions[i].imageSubresource);
if (vkb_emu_copy_buffer_to_image(e, cb, src, dst, dl, n, regions)) return;
vkb_emu_real()->vkCmdCopyBufferToImage(cb, src, dst, dl, n, regions);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyBufferToImage2(VkCommandBuffer cb, const VkCopyBufferToImageInfo2 *info)
{
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < info->regionCount; i++)
fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].imageSubresource);
if (vkb_emu_copy_buffer_to_image2(e, cb, info)) return;
vkb_emu_real()->vkCmdCopyBufferToImage2(cb, info);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImageToBuffer(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkBuffer dst, uint32_t n,
const VkBufferImageCopy *regions)
{
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < n; i++) fix_layers(e, src, (VkImageSubresourceLayers *)&regions[i].imageSubresource);
vkb_emu_real()->vkCmdCopyImageToBuffer(cb, src, sl, dst, n, regions);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImageToBuffer2(VkCommandBuffer cb, const VkCopyImageToBufferInfo2 *info)
{
vkb_emu_device *e = vkb_emu_cur();
for (uint32_t i = 0; i < info->regionCount; i++)
fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].imageSubresource);
vkb_emu_real()->vkCmdCopyImageToBuffer2(cb, info);
}
static VKAPI_ATTR void VKAPI_CALL emu_CmdBindVertexBuffers2(VkCommandBuffer cb, uint32_t first, uint32_t n, const VkBuffer *buffers,
const VkDeviceSize *offsets, const VkDeviceSize *sizes,
const VkDeviceSize *strides)
{
vkb_emu_device *e = vkb_emu_cur();
if (sizes) {
VkDeviceSize *s = (VkDeviceSize *)sizes;
for (uint32_t i = 0; i < n; i++) {
if (s[i] != VK_WHOLE_SIZE || !buffers[i]) continue;
VkDeviceSize total = buffer_size(e, buffers[i]);
s[i] = total > offsets[i] ? total - offsets[i] : 0;
}
}
vkb_emu_real()->vkCmdBindVertexBuffers2(cb, first, n, buffers, offsets, sizes, strides);
}
/* ------------------------------------------------------------------ install */
void vkb_emu_install(vkb_srv_table *dev)
{
(void)dev;
vkb_emu_device *e = dev->emu;
vkb_dispatch *dt = &dev->dt;
/* Resource records are needed by every emulation. */
dt->vkCreateBuffer = emu_CreateBuffer;
dt->vkDestroyBuffer = emu_DestroyBuffer;
dt->vkCreateImage = emu_CreateImage;
dt->vkDestroyImage = emu_DestroyImage;
dt->vkCreateGraphicsPipelines = emu_CreateGraphicsPipelines;
dt->vkCreateComputePipelines = emu_CreateComputePipelines;
dt->vkCmdCopyImage = emu_CmdCopyImage;
dt->vkCmdCopyBufferToImage = emu_CmdCopyBufferToImage;
if (dev->real.vkCmdCopyImage2) dt->vkCmdCopyImage2 = emu_CmdCopyImage2;
if (dev->real.vkCmdCopyBufferToImage2) dt->vkCmdCopyBufferToImage2 = emu_CmdCopyBufferToImage2;
if (e->flags & VKB_EMU_MAINT5) {
dt->vkCreateBufferView = emu_CreateBufferView;
dt->vkCmdBindIndexBuffer2 = emu_CmdBindIndexBuffer2;
dt->vkGetRenderingAreaGranularity = emu_GetRenderingAreaGranularity;
dt->vkGetImageSubresourceLayout2 = emu_GetImageSubresourceLayout2;
dt->vkGetDeviceImageSubresourceLayout = emu_GetDeviceImageSubresourceLayout;
dt->vkCmdBlitImage = emu_CmdBlitImage;
dt->vkCmdResolveImage = emu_CmdResolveImage;
dt->vkCmdCopyImageToBuffer = emu_CmdCopyImageToBuffer;
if (dev->real.vkCmdBlitImage2) dt->vkCmdBlitImage2 = emu_CmdBlitImage2;
if (dev->real.vkCmdResolveImage2) dt->vkCmdResolveImage2 = emu_CmdResolveImage2;
if (dev->real.vkCmdCopyImageToBuffer2) dt->vkCmdCopyImageToBuffer2 = emu_CmdCopyImageToBuffer2;
if (dev->real.vkCmdBindVertexBuffers2) dt->vkCmdBindVertexBuffers2 = emu_CmdBindVertexBuffers2;
}
vkb_emu_install_features(dev);
VKB_INFO("device %u: emulation 0x%x installed", dev->id, e->flags);
}
void vkb_emu_uninstall(vkb_srv_table *dev)
{
(void)dev;
vkb_emu_device *e = dev->emu;
vkb_emu_uninstall_features(dev);
for (int i = 0; i < VKB_EMU_BUCKETS; i++) {
while (e->images[i]) {
vkb_emu_image *r = e->images[i];
e->images[i] = r->next;
vkb_emu_image_release(e, r);
free(r);
}
while (e->buffers[i]) {
vkb_emu_buffer *r = e->buffers[i];
e->buffers[i] = r->next;
free(r);
}
}
}