mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 22:05:59 +00:00
Squash of Droid-Deck/DroidDeck#517 (ASEbrahim/DroidDeck mali-bridge @ 6b823341): the Vulkan
bridge (tools/vkbridge) that runs the guest's Vulkan on the phone's own driver, with BC1-BC7,
clip/cull distance, vertex-divisor and depth-clip emulation and dma-heap memory sharing for Mali.
All of the bridge is ASEbrahim's work; squashed only to carry it on this test branch.
Combined with #570 on this branch, a device draws through exactly one path:
- Adreno: Turnip, unchanged (checked first; the bridge setting is ignored there).
- PowerVR / Xclipse with the system HAL and a render node: the system-Vulkan path (#570).
- Anything else with the Setup toggle on (Mali): the bridge.
7020 lines
335 KiB
C
7020 lines
335 KiB
C
/* Generated by tools/vkbridge/codegen/gen_vkbridge.py from vk.xml 1.4.341 - do not edit. */
|
|
|
|
#include "vkb_gen.h"
|
|
#include "vkb_client_gen.h"
|
|
#include "../vkb_wire.h"
|
|
#include "../../client/vkb_client.h"
|
|
#include <string.h>
|
|
|
|
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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
vkb_call_end(&call_);
|
|
return r_;
|
|
}
|
|
|
|
VkResult vkb_wire_vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkBindTensorMemoryARM, 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_VkBindTensorMemoryInfoARM(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_vkCmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBeginCustomResolveEXT);
|
|
if (!e) return;
|
|
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
|
|
if (pBeginCustomResolveInfo) {
|
|
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_VkBeginCustomResolveInfoEXT(e, &pBeginCustomResolveInfo[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_vkCmdBindDescriptorSets2(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBindDescriptorSets2);
|
|
if (!e) return;
|
|
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
|
|
if (pBindDescriptorSetsInfo) {
|
|
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_VkBindDescriptorSetsInfo(e, &pBindDescriptorSetsInfo[i_]);
|
|
} 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_vkCmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdBindIndexBuffer2);
|
|
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, &size, sizeof(size));
|
|
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_vkCmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdCopyTensorARM);
|
|
if (!e) return;
|
|
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
|
|
if (pCopyTensorInfo) {
|
|
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_VkCopyTensorInfoARM(e, &pCopyTensorInfo[i_]);
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
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_vkCmdEndRendering2KHR(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdEndRendering2KHR);
|
|
if (!e) return;
|
|
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
|
|
if (pRenderingEndInfo) {
|
|
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_VkRenderingEndInfoKHR(e, &pRenderingEndInfo[i_]);
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
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_vkCmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdPushConstants2);
|
|
if (!e) return;
|
|
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
|
|
if (pPushConstantsInfo) {
|
|
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_VkPushConstantsInfo(e, &pPushConstantsInfo[i_]);
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
vkb_cmd_record_end(commandBuffer);
|
|
}
|
|
|
|
void vkb_wire_vkCmdPushDescriptorSet(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_vkCmdPushDescriptorSet);
|
|
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_vkCmdPushDescriptorSet2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdPushDescriptorSet2);
|
|
if (!e) return;
|
|
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
|
|
if (pPushDescriptorSetInfo) {
|
|
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_VkPushDescriptorSetInfo(e, &pPushDescriptorSetInfo[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_vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetAttachmentFeedbackLoopEnableEXT);
|
|
if (!e) return;
|
|
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
|
|
vkb_enc_bytes(e, &aspectMask, sizeof(aspectMask));
|
|
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_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_vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthBias2EXT);
|
|
if (!e) return;
|
|
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
|
|
if (pDepthBiasInfo) {
|
|
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_VkDepthBiasInfoEXT(e, &pDepthBiasInfo[i_]);
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
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_vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetDepthClampRangeEXT);
|
|
if (!e) return;
|
|
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
|
|
vkb_enc_bytes(e, &depthClampMode, sizeof(depthClampMode));
|
|
if (pDepthClampRange) {
|
|
uint32_t n_ = (uint32_t)(1);
|
|
vkb_enc_u8(e, 1); vkb_enc_u32(e, n_);
|
|
vkb_enc_raw(e, pDepthClampRange, (size_t)n_ * sizeof(*pDepthClampRange));
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
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_vkCmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetLineStipple);
|
|
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_vkCmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetRenderingAttachmentLocations);
|
|
if (!e) return;
|
|
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
|
|
if (pLocationInfo) {
|
|
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_VkRenderingAttachmentLocationInfo(e, &pLocationInfo[i_]);
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
vkb_cmd_record_end(commandBuffer);
|
|
}
|
|
|
|
void vkb_wire_vkCmdSetRenderingInputAttachmentIndices(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo)
|
|
{
|
|
vkb_enc *e = vkb_cmd_record_begin(commandBuffer, VKB_CMD_vkCmdSetRenderingInputAttachmentIndices);
|
|
if (!e) return;
|
|
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
|
|
if (pInputAttachmentIndexInfo) {
|
|
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_VkRenderingInputAttachmentIndexInfo(e, &pInputAttachmentIndexInfo[i_]);
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
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_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_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_;
|
|
}
|
|
|
|
VkResult vkb_wire_vkCreateTensorARM(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkCreateTensorARM, 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_VkTensorCreateInfoARM(e, &pCreateInfo[i_]);
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
(void)pAllocator;
|
|
vkb_enc_u8(e, pTensor != NULL);
|
|
if (pTensor) vkb_enc_bytes(e, pTensor, sizeof(*pTensor));
|
|
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 (pTensor) vkb_dec_raw_into(d, pTensor, sizeof(*pTensor)); else d->err = 1;
|
|
}
|
|
vkb_call_end(&call_);
|
|
return r_;
|
|
}
|
|
|
|
VkResult vkb_wire_vkCreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkCreateTensorViewARM, 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_VkTensorViewCreateInfoARM(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_;
|
|
}
|
|
|
|
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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&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;
|
|
vkb_call_exec_async(&call_);
|
|
}
|
|
|
|
void vkb_wire_vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkDestroyTensorARM, vkb_table_of((const void *)device));
|
|
vkb_enc *e = &call_.e;
|
|
vkb_enc_u64(e, vkb_remote((const void *)device));
|
|
vkb_enc_bytes(e, &tensor, sizeof(tensor));
|
|
(void)pAllocator;
|
|
vkb_call_exec_async(&call_);
|
|
}
|
|
|
|
void vkb_wire_vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkDestroyTensorViewARM, vkb_table_of((const void *)device));
|
|
vkb_enc *e = &call_.e;
|
|
vkb_enc_u64(e, vkb_remote((const void *)device));
|
|
vkb_enc_bytes(e, &tensorView, sizeof(tensorView));
|
|
(void)pAllocator;
|
|
vkb_call_exec_async(&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_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, vkb_table_of((const void *)physicalDevice));
|
|
vkb_enc *e = &call_.e;
|
|
vkb_enc_u64(e, vkb_remote((const void *)physicalDevice));
|
|
vkb_enc_bytes(e, &queueFamilyIndex, sizeof(queueFamilyIndex));
|
|
vkb_enc_u8(e, pCounterCount != NULL);
|
|
if (pCounterCount) vkb_enc_bytes(e, pCounterCount, sizeof(*pCounterCount));
|
|
{ uint32_t n_ = pCounters ? (uint32_t)((pCounterCount ? *pCounterCount : 0)) : 0;
|
|
vkb_enc_u8(e, pCounters != NULL); vkb_enc_u32(e, n_);
|
|
for (uint32_t i_ = 0; pCounters && i_ < n_; i_++) vkb_enc_out_template(e, &pCounters[i_], sizeof(VkPerformanceCounterARM));
|
|
}
|
|
{ uint32_t n_ = pCounterDescriptions ? (uint32_t)((pCounterCount ? *pCounterCount : 0)) : 0;
|
|
vkb_enc_u8(e, pCounterDescriptions != NULL); vkb_enc_u32(e, n_);
|
|
for (uint32_t i_ = 0; pCounterDescriptions && i_ < n_; i_++) vkb_enc_out_template(e, &pCounterDescriptions[i_], sizeof(VkPerformanceCounterDescriptionARM));
|
|
}
|
|
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 (pCounterCount) vkb_dec_raw_into(d, pCounterCount, sizeof(*pCounterCount)); else d->err = 1;
|
|
}
|
|
{
|
|
uint32_t rn_ = vkb_dec_u32(d);
|
|
(void)rn_;
|
|
uint32_t cap_ = (pCounters && pCounterCount) ? *pCounterCount : 0;
|
|
if (pCounterCount) *pCounterCount = 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, &pCounters[i_], sizeof(VkPerformanceCounterARM));
|
|
}
|
|
}
|
|
{
|
|
uint32_t rn_ = vkb_dec_u32(d);
|
|
(void)rn_;
|
|
uint32_t cap_ = (pCounterDescriptions && pCounterCount) ? *pCounterCount : 0;
|
|
if (pCounterCount) *pCounterCount = 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, &pCounterDescriptions[i_], sizeof(VkPerformanceCounterDescriptionARM));
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
vkb_call_exec_async(&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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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;
|
|
vkb_call_exec_async(&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_vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkGetCalibratedTimestampsKHR, 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_VkCalibratedTimestampInfoKHR(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_vkGetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkGetDeviceImageSubresourceLayout, 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_VkDeviceImageSubresourceInfo(e, &pInfo[i_]);
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
vkb_enc_u8(e, pLayout != NULL);
|
|
if (pLayout) vkb_enc_out_template(e, pLayout, sizeof(VkSubresourceLayout2));
|
|
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(VkSubresourceLayout2)); else d->err = 1;
|
|
}
|
|
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_);
|
|
}
|
|
|
|
void vkb_wire_vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkGetDeviceTensorMemoryRequirementsARM, 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_VkDeviceTensorMemoryRequirementsARM(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_);
|
|
}
|
|
|
|
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_vkGetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkGetImageSubresourceLayout2, 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_VkImageSubresource2(e, &pSubresource[i_]);
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
vkb_enc_u8(e, pLayout != NULL);
|
|
if (pLayout) vkb_enc_out_template(e, pLayout, sizeof(VkSubresourceLayout2));
|
|
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(VkSubresourceLayout2)); 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_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, 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(VkTimeDomainKHR));
|
|
}
|
|
}
|
|
vkb_call_end(&call_);
|
|
return r_;
|
|
}
|
|
|
|
VkResult vkb_wire_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, vkb_table_of((const void *)physicalDevice));
|
|
vkb_enc *e = &call_.e;
|
|
vkb_enc_u64(e, vkb_remote((const void *)physicalDevice));
|
|
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(VkCooperativeMatrixPropertiesKHR));
|
|
}
|
|
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_out_struct(d, &pProperties[i_], sizeof(VkCooperativeMatrixPropertiesKHR));
|
|
}
|
|
}
|
|
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_vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkGetPhysicalDeviceExternalTensorPropertiesARM, vkb_table_of((const void *)physicalDevice));
|
|
vkb_enc *e = &call_.e;
|
|
vkb_enc_u64(e, vkb_remote((const void *)physicalDevice));
|
|
if (pExternalTensorInfo) {
|
|
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_VkPhysicalDeviceExternalTensorInfoARM(e, &pExternalTensorInfo[i_]);
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
vkb_enc_u8(e, pExternalTensorProperties != NULL);
|
|
if (pExternalTensorProperties) vkb_enc_out_template(e, pExternalTensorProperties, sizeof(VkExternalTensorPropertiesARM));
|
|
if (!vkb_call_exec(&call_)) {
|
|
return;
|
|
}
|
|
vkb_dec *d = &call_.d;
|
|
(void)d;
|
|
if (vkb_dec_u8(d)) {
|
|
if (pExternalTensorProperties) vkb_dec_out_struct(d, pExternalTensorProperties, sizeof(VkExternalTensorPropertiesARM)); 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_);
|
|
}
|
|
|
|
void vkb_wire_vkGetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkGetRenderingAreaGranularity, vkb_table_of((const void *)device));
|
|
vkb_enc *e = &call_.e;
|
|
vkb_enc_u64(e, vkb_remote((const void *)device));
|
|
if (pRenderingAreaInfo) {
|
|
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_VkRenderingAreaInfo(e, &pRenderingAreaInfo[i_]);
|
|
} else {
|
|
vkb_enc_u8(e, 0);
|
|
}
|
|
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_);
|
|
}
|
|
|
|
void vkb_wire_vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements)
|
|
{
|
|
vkb_call call_;
|
|
vkb_call_begin(&call_, VKB_CMD_vkGetTensorMemoryRequirementsARM, 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_VkTensorMemoryRequirementsInfoARM(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_);
|
|
}
|
|
|
|
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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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));
|
|
vkb_call_exec_async(&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));
|
|
vkb_call_exec_async(&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_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
|
|
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
|
|
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
|
|
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));
|
|
vkb_call_exec_async(&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);
|
|
}
|
|
vkb_call_exec_async(&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_vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos)
|
|
{
|
|
return vkb_wire_vkBindTensorMemoryARM(device, bindInfoCount, pBindInfos);
|
|
}
|
|
|
|
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_vkCmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo)
|
|
{
|
|
vkb_wire_vkCmdBeginCustomResolveEXT(commandBuffer, pBeginCustomResolveInfo);
|
|
}
|
|
|
|
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_vkCmdBindDescriptorSets2(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo)
|
|
{
|
|
vkb_wire_vkCmdBindDescriptorSets2(commandBuffer, pBindDescriptorSetsInfo);
|
|
}
|
|
|
|
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_vkCmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
|
|
{
|
|
vkb_wire_vkCmdBindIndexBuffer2(commandBuffer, buffer, offset, size, 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_vkCmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo)
|
|
{
|
|
vkb_wire_vkCmdCopyTensorARM(commandBuffer, pCopyTensorInfo);
|
|
}
|
|
|
|
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_vkCmdEndRendering2KHR(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo)
|
|
{
|
|
vkb_wire_vkCmdEndRendering2KHR(commandBuffer, pRenderingEndInfo);
|
|
}
|
|
|
|
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_vkCmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo)
|
|
{
|
|
vkb_wire_vkCmdPushConstants2(commandBuffer, pPushConstantsInfo);
|
|
}
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdPushDescriptorSet(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites)
|
|
{
|
|
vkb_wire_vkCmdPushDescriptorSet(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
|
|
}
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdPushDescriptorSet2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo)
|
|
{
|
|
vkb_wire_vkCmdPushDescriptorSet2(commandBuffer, pPushDescriptorSetInfo);
|
|
}
|
|
|
|
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_vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask)
|
|
{
|
|
vkb_wire_vkCmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer, aspectMask);
|
|
}
|
|
|
|
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_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_vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo)
|
|
{
|
|
vkb_wire_vkCmdSetDepthBias2EXT(commandBuffer, pDepthBiasInfo);
|
|
}
|
|
|
|
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_vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange)
|
|
{
|
|
vkb_wire_vkCmdSetDepthClampRangeEXT(commandBuffer, depthClampMode, pDepthClampRange);
|
|
}
|
|
|
|
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_vkCmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
|
|
{
|
|
vkb_wire_vkCmdSetLineStipple(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_vkCmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo)
|
|
{
|
|
vkb_wire_vkCmdSetRenderingAttachmentLocations(commandBuffer, pLocationInfo);
|
|
}
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdSetRenderingInputAttachmentIndices(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo)
|
|
{
|
|
vkb_wire_vkCmdSetRenderingInputAttachmentIndices(commandBuffer, pInputAttachmentIndexInfo);
|
|
}
|
|
|
|
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_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_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_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 VkResult VKAPI_CALL vkb_ep_vkCreateTensorARM(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor)
|
|
{
|
|
return vkb_wire_vkCreateTensorARM(device, pCreateInfo, pAllocator, pTensor);
|
|
}
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView)
|
|
{
|
|
return vkb_wire_vkCreateTensorViewARM(device, pCreateInfo, pAllocator, pView);
|
|
}
|
|
|
|
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_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 void VKAPI_CALL vkb_ep_vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator)
|
|
{
|
|
vkb_wire_vkDestroyTensorARM(device, tensor, pAllocator);
|
|
}
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator)
|
|
{
|
|
vkb_wire_vkDestroyTensorViewARM(device, tensorView, pAllocator);
|
|
}
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions)
|
|
{
|
|
return vkb_wire_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
|
|
}
|
|
|
|
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_vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
|
|
{
|
|
return vkb_wire_vkGetCalibratedTimestampsKHR(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_vkGetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout)
|
|
{
|
|
vkb_wire_vkGetDeviceImageSubresourceLayout(device, pInfo, pLayout);
|
|
}
|
|
|
|
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 void VKAPI_CALL vkb_ep_vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements)
|
|
{
|
|
vkb_wire_vkGetDeviceTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements);
|
|
}
|
|
|
|
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_vkGetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout)
|
|
{
|
|
vkb_wire_vkGetImageSubresourceLayout2(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_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains)
|
|
{
|
|
return vkb_wire_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, pTimeDomainCount, pTimeDomains);
|
|
}
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties)
|
|
{
|
|
return vkb_wire_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
|
|
}
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties)
|
|
{
|
|
vkb_wire_vkGetPhysicalDeviceExternalTensorPropertiesARM(physicalDevice, pExternalTensorInfo, pExternalTensorProperties);
|
|
}
|
|
|
|
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 void VKAPI_CALL vkb_ep_vkGetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity)
|
|
{
|
|
vkb_wire_vkGetRenderingAreaGranularity(device, pRenderingAreaInfo, 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 void VKAPI_CALL vkb_ep_vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements)
|
|
{
|
|
vkb_wire_vkGetTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements);
|
|
}
|
|
|
|
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_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", 0},
|
|
{"vkAcquireNextImageKHR", (PFN_vkVoidFunction)vkb_ep_vkAcquireNextImageKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0},
|
|
{"vkAllocateCommandBuffers", (PFN_vkVoidFunction)vkb_ep_vkAllocateCommandBuffers, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkAllocateDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkAllocateDescriptorSets, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkAllocateMemory", (PFN_vkVoidFunction)vkb_ep_vkAllocateMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkBeginCommandBuffer", (PFN_vkVoidFunction)vkb_ep_vkBeginCommandBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkBindBufferMemory", (PFN_vkVoidFunction)vkb_ep_vkBindBufferMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkBindBufferMemory2", (PFN_vkVoidFunction)vkb_ep_vkBindBufferMemory2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkBindBufferMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkBindBufferMemory2, VKB_LEVEL_DEVICE, "VK_KHR_bind_memory2", 0},
|
|
{"vkBindImageMemory", (PFN_vkVoidFunction)vkb_ep_vkBindImageMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkBindImageMemory2", (PFN_vkVoidFunction)vkb_ep_vkBindImageMemory2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkBindImageMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkBindImageMemory2, VKB_LEVEL_DEVICE, "VK_KHR_bind_memory2", 0},
|
|
{"vkBindTensorMemoryARM", (PFN_vkVoidFunction)vkb_ep_vkBindTensorMemoryARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0},
|
|
{"vkCmdBeginConditionalRenderingEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginConditionalRenderingEXT, VKB_LEVEL_DEVICE, "VK_EXT_conditional_rendering", 0},
|
|
{"vkCmdBeginCustomResolveEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginCustomResolveEXT, VKB_LEVEL_DEVICE, "VK_EXT_custom_resolve", 0},
|
|
{"vkCmdBeginDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0},
|
|
{"vkCmdBeginQuery", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginQuery, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdBeginQueryIndexedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginQueryIndexedEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0},
|
|
{"vkCmdBeginRenderPass", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRenderPass, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdBeginRenderPass2", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRenderPass2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkCmdBeginRenderPass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRenderPass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2", 0},
|
|
{"vkCmdBeginRendering", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRendering, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdBeginRenderingKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRendering, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering", 0},
|
|
{"vkCmdBeginTransformFeedbackEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginTransformFeedbackEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0},
|
|
{"vkCmdBindDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkCmdBindDescriptorSets, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdBindDescriptorSets2", (PFN_vkVoidFunction)vkb_ep_vkCmdBindDescriptorSets2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCmdBindDescriptorSets2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBindDescriptorSets2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6", 0},
|
|
{"vkCmdBindIndexBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdBindIndexBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdBindIndexBuffer2", (PFN_vkVoidFunction)vkb_ep_vkCmdBindIndexBuffer2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCmdBindIndexBuffer2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBindIndexBuffer2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5", 0},
|
|
{"vkCmdBindPipeline", (PFN_vkVoidFunction)vkb_ep_vkCmdBindPipeline, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdBindTransformFeedbackBuffersEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBindTransformFeedbackBuffersEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0},
|
|
{"vkCmdBindVertexBuffers", (PFN_vkVoidFunction)vkb_ep_vkCmdBindVertexBuffers, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdBindVertexBuffers2", (PFN_vkVoidFunction)vkb_ep_vkCmdBindVertexBuffers2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdBindVertexBuffers2EXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBindVertexBuffers2, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdBlitImage", (PFN_vkVoidFunction)vkb_ep_vkCmdBlitImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdBlitImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdBlitImage2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdBlitImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBlitImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0},
|
|
{"vkCmdClearAttachments", (PFN_vkVoidFunction)vkb_ep_vkCmdClearAttachments, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdClearColorImage", (PFN_vkVoidFunction)vkb_ep_vkCmdClearColorImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdClearDepthStencilImage", (PFN_vkVoidFunction)vkb_ep_vkCmdClearDepthStencilImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdCopyBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdCopyBuffer2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBuffer2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdCopyBuffer2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBuffer2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0},
|
|
{"vkCmdCopyBufferToImage", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBufferToImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdCopyBufferToImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBufferToImage2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdCopyBufferToImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBufferToImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0},
|
|
{"vkCmdCopyImage", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdCopyImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImage2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdCopyImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0},
|
|
{"vkCmdCopyImageToBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImageToBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdCopyImageToBuffer2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImageToBuffer2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdCopyImageToBuffer2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImageToBuffer2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0},
|
|
{"vkCmdCopyQueryPoolResults", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyQueryPoolResults, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdCopyTensorARM", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyTensorARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0},
|
|
{"vkCmdDispatch", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatch, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdDispatchBase", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatchBase, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkCmdDispatchBaseKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatchBase, VKB_LEVEL_DEVICE, "VK_KHR_device_group", 0},
|
|
{"vkCmdDispatchIndirect", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatchIndirect, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdDraw", (PFN_vkVoidFunction)vkb_ep_vkCmdDraw, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdDrawIndexed", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexed, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdDrawIndexedIndirect", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirect, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdDrawIndexedIndirectCount", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirectCount, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkCmdDrawIndexedIndirectCountAMD", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirectCount, VKB_LEVEL_DEVICE, NULL, 0},
|
|
{"vkCmdDrawIndexedIndirectCountKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirectCount, VKB_LEVEL_DEVICE, "VK_KHR_draw_indirect_count", 0},
|
|
{"vkCmdDrawIndirect", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirect, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdDrawIndirectByteCountEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectByteCountEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0},
|
|
{"vkCmdDrawIndirectCount", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectCount, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkCmdDrawIndirectCountAMD", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectCount, VKB_LEVEL_DEVICE, NULL, 0},
|
|
{"vkCmdDrawIndirectCountKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectCount, VKB_LEVEL_DEVICE, "VK_KHR_draw_indirect_count", 0},
|
|
{"vkCmdDrawMultiEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawMultiEXT, VKB_LEVEL_DEVICE, "VK_EXT_multi_draw", 0},
|
|
{"vkCmdDrawMultiIndexedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawMultiIndexedEXT, VKB_LEVEL_DEVICE, "VK_EXT_multi_draw", 0},
|
|
{"vkCmdEndConditionalRenderingEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndConditionalRenderingEXT, VKB_LEVEL_DEVICE, "VK_EXT_conditional_rendering", 0},
|
|
{"vkCmdEndDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0},
|
|
{"vkCmdEndQuery", (PFN_vkVoidFunction)vkb_ep_vkCmdEndQuery, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdEndQueryIndexedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndQueryIndexedEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0},
|
|
{"vkCmdEndRenderPass", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRenderPass, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdEndRenderPass2", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRenderPass2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkCmdEndRenderPass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRenderPass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2", 0},
|
|
{"vkCmdEndRendering", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdEndRendering2EXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering2KHR, VKB_LEVEL_DEVICE, NULL, 0},
|
|
{"vkCmdEndRendering2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering2KHR, VKB_LEVEL_DEVICE, "VK_KHR_maintenance10", 0},
|
|
{"vkCmdEndRenderingKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering", 0},
|
|
{"vkCmdEndTransformFeedbackEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndTransformFeedbackEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0},
|
|
{"vkCmdExecuteCommands", (PFN_vkVoidFunction)vkb_ep_vkCmdExecuteCommands, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdFillBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdFillBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdInsertDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdInsertDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0},
|
|
{"vkCmdNextSubpass", (PFN_vkVoidFunction)vkb_ep_vkCmdNextSubpass, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdNextSubpass2", (PFN_vkVoidFunction)vkb_ep_vkCmdNextSubpass2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkCmdNextSubpass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdNextSubpass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2", 0},
|
|
{"vkCmdPipelineBarrier", (PFN_vkVoidFunction)vkb_ep_vkCmdPipelineBarrier, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdPipelineBarrier2", (PFN_vkVoidFunction)vkb_ep_vkCmdPipelineBarrier2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdPipelineBarrier2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPipelineBarrier2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0},
|
|
{"vkCmdPushConstants", (PFN_vkVoidFunction)vkb_ep_vkCmdPushConstants, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdPushConstants2", (PFN_vkVoidFunction)vkb_ep_vkCmdPushConstants2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCmdPushConstants2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushConstants2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6", 0},
|
|
{"vkCmdPushDescriptorSet", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCmdPushDescriptorSet2", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCmdPushDescriptorSet2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6", 0},
|
|
{"vkCmdPushDescriptorSetKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet, VKB_LEVEL_DEVICE, "VK_KHR_push_descriptor", 0},
|
|
{"vkCmdPushDescriptorSetWithTemplate", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCmdPushDescriptorSetWithTemplate2", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCmdPushDescriptorSetWithTemplate2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6", 0},
|
|
{"vkCmdPushDescriptorSetWithTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, "VK_KHR_push_descriptor", 0},
|
|
{"vkCmdResetEvent", (PFN_vkVoidFunction)vkb_ep_vkCmdResetEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdResetEvent2", (PFN_vkVoidFunction)vkb_ep_vkCmdResetEvent2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdResetEvent2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdResetEvent2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0},
|
|
{"vkCmdResetQueryPool", (PFN_vkVoidFunction)vkb_ep_vkCmdResetQueryPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdResolveImage", (PFN_vkVoidFunction)vkb_ep_vkCmdResolveImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdResolveImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdResolveImage2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdResolveImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdResolveImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0},
|
|
{"vkCmdSetAlphaToCoverageEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetAlphaToCoverageEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetAlphaToOneEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetAlphaToOneEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetAttachmentFeedbackLoopEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetAttachmentFeedbackLoopEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_attachment_feedback_loop_dynamic_state", 0},
|
|
{"vkCmdSetBlendConstants", (PFN_vkVoidFunction)vkb_ep_vkCmdSetBlendConstants, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdSetColorBlendAdvancedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorBlendAdvancedEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetColorBlendEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorBlendEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetColorBlendEquationEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorBlendEquationEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetColorWriteEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorWriteEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_color_write_enable", 0},
|
|
{"vkCmdSetColorWriteMaskEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorWriteMaskEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetConservativeRasterizationModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetConservativeRasterizationModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetCullMode", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCullMode, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetCullModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCullMode, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdSetDepthBias", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBias, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdSetDepthBias2EXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBias2EXT, VKB_LEVEL_DEVICE, "VK_EXT_depth_bias_control", 0},
|
|
{"vkCmdSetDepthBiasEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBiasEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetDepthBiasEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBiasEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2", 0},
|
|
{"vkCmdSetDepthBounds", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBounds, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdSetDepthBoundsTestEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBoundsTestEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetDepthBoundsTestEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBoundsTestEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdSetDepthClampEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClampEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetDepthClampRangeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClampRangeEXT, VKB_LEVEL_DEVICE, "VK_EXT_depth_clamp_control", 0},
|
|
{"vkCmdSetDepthClipEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClipEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetDepthClipNegativeOneToOneEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClipNegativeOneToOneEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetDepthCompareOp", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthCompareOp, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetDepthCompareOpEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthCompareOp, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdSetDepthTestEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthTestEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetDepthTestEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthTestEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdSetDepthWriteEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthWriteEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetDepthWriteEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthWriteEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdSetDeviceMask", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDeviceMask, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkCmdSetDeviceMaskKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDeviceMask, VKB_LEVEL_DEVICE, "VK_KHR_device_group", 0},
|
|
{"vkCmdSetDiscardRectangleEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDiscardRectangleEXT, VKB_LEVEL_DEVICE, "VK_EXT_discard_rectangles", 0},
|
|
{"vkCmdSetDiscardRectangleEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDiscardRectangleEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_discard_rectangles", 0},
|
|
{"vkCmdSetDiscardRectangleModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDiscardRectangleModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_discard_rectangles", 0},
|
|
{"vkCmdSetEvent", (PFN_vkVoidFunction)vkb_ep_vkCmdSetEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdSetEvent2", (PFN_vkVoidFunction)vkb_ep_vkCmdSetEvent2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetEvent2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetEvent2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0},
|
|
{"vkCmdSetExtraPrimitiveOverestimationSizeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetExtraPrimitiveOverestimationSizeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetFragmentShadingRateKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetFragmentShadingRateKHR, VKB_LEVEL_DEVICE, "VK_KHR_fragment_shading_rate", 0},
|
|
{"vkCmdSetFrontFace", (PFN_vkVoidFunction)vkb_ep_vkCmdSetFrontFace, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetFrontFaceEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetFrontFace, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdSetLineRasterizationModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineRasterizationModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetLineStipple", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStipple, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCmdSetLineStippleEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStipple, VKB_LEVEL_DEVICE, "VK_EXT_line_rasterization", 0},
|
|
{"vkCmdSetLineStippleEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStippleEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetLineStippleKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStipple, VKB_LEVEL_DEVICE, "VK_KHR_line_rasterization", 0},
|
|
{"vkCmdSetLineWidth", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineWidth, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdSetLogicOpEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLogicOpEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2", 0},
|
|
{"vkCmdSetLogicOpEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLogicOpEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetPatchControlPointsEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPatchControlPointsEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2", 0},
|
|
{"vkCmdSetPolygonModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPolygonModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetPrimitiveRestartEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveRestartEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetPrimitiveRestartEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveRestartEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2", 0},
|
|
{"vkCmdSetPrimitiveTopology", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveTopology, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetPrimitiveTopologyEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveTopology, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdSetProvokingVertexModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetProvokingVertexModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetRasterizationSamplesEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizationSamplesEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetRasterizationStreamEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizationStreamEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetRasterizerDiscardEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizerDiscardEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetRasterizerDiscardEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizerDiscardEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2", 0},
|
|
{"vkCmdSetRenderingAttachmentLocations", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingAttachmentLocations, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCmdSetRenderingAttachmentLocationsKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingAttachmentLocations, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering_local_read", 0},
|
|
{"vkCmdSetRenderingInputAttachmentIndices", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingInputAttachmentIndices, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCmdSetRenderingInputAttachmentIndicesKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingInputAttachmentIndices, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering_local_read", 0},
|
|
{"vkCmdSetSampleLocationsEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetSampleLocationsEXT, VKB_LEVEL_DEVICE, "VK_EXT_sample_locations", 0},
|
|
{"vkCmdSetSampleLocationsEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetSampleLocationsEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetSampleMaskEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetSampleMaskEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetScissor", (PFN_vkVoidFunction)vkb_ep_vkCmdSetScissor, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdSetScissorWithCount", (PFN_vkVoidFunction)vkb_ep_vkCmdSetScissorWithCount, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetScissorWithCountEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetScissorWithCount, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdSetStencilCompareMask", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilCompareMask, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdSetStencilOp", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilOp, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetStencilOpEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilOp, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdSetStencilReference", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilReference, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdSetStencilTestEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilTestEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetStencilTestEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilTestEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdSetStencilWriteMask", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilWriteMask, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdSetTessellationDomainOriginEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetTessellationDomainOriginEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0},
|
|
{"vkCmdSetVertexInputEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetVertexInputEXT, VKB_LEVEL_DEVICE, "VK_EXT_vertex_input_dynamic_state", 0},
|
|
{"vkCmdSetViewport", (PFN_vkVoidFunction)vkb_ep_vkCmdSetViewport, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdSetViewportWithCount", (PFN_vkVoidFunction)vkb_ep_vkCmdSetViewportWithCount, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdSetViewportWithCountEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetViewportWithCount, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0},
|
|
{"vkCmdUpdateBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdUpdateBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdWaitEvents", (PFN_vkVoidFunction)vkb_ep_vkCmdWaitEvents, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdWaitEvents2", (PFN_vkVoidFunction)vkb_ep_vkCmdWaitEvents2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdWaitEvents2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdWaitEvents2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0},
|
|
{"vkCmdWriteTimestamp", (PFN_vkVoidFunction)vkb_ep_vkCmdWriteTimestamp, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCmdWriteTimestamp2", (PFN_vkVoidFunction)vkb_ep_vkCmdWriteTimestamp2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCmdWriteTimestamp2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdWriteTimestamp2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0},
|
|
{"vkCopyImageToImage", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCopyImageToImageEXT", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToImage, VKB_LEVEL_DEVICE, NULL, 0},
|
|
{"vkCopyImageToMemory", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCopyImageToMemoryEXT", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToMemory, VKB_LEVEL_DEVICE, NULL, 0},
|
|
{"vkCopyMemoryToImage", (PFN_vkVoidFunction)vkb_ep_vkCopyMemoryToImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkCopyMemoryToImageEXT", (PFN_vkVoidFunction)vkb_ep_vkCopyMemoryToImage, VKB_LEVEL_DEVICE, NULL, 0},
|
|
{"vkCreateBuffer", (PFN_vkVoidFunction)vkb_ep_vkCreateBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateBufferView", (PFN_vkVoidFunction)vkb_ep_vkCreateBufferView, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateCommandPool", (PFN_vkVoidFunction)vkb_ep_vkCreateCommandPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateComputePipelines", (PFN_vkVoidFunction)vkb_ep_vkCreateComputePipelines, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateDebugUtilsMessengerEXT", (PFN_vkVoidFunction)vkb_ep_vkCreateDebugUtilsMessengerEXT, VKB_LEVEL_INSTANCE, "VK_EXT_debug_utils", 0},
|
|
{"vkCreateDescriptorPool", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateDescriptorSetLayout", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorSetLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateDescriptorUpdateTemplate", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkCreateDescriptorUpdateTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, "VK_KHR_descriptor_update_template", 0},
|
|
{"vkCreateDevice", (PFN_vkVoidFunction)vkb_ep_vkCreateDevice, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateEvent", (PFN_vkVoidFunction)vkb_ep_vkCreateEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateFence", (PFN_vkVoidFunction)vkb_ep_vkCreateFence, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateFramebuffer", (PFN_vkVoidFunction)vkb_ep_vkCreateFramebuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateGraphicsPipelines", (PFN_vkVoidFunction)vkb_ep_vkCreateGraphicsPipelines, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateHeadlessSurfaceEXT", (PFN_vkVoidFunction)vkb_ep_vkCreateHeadlessSurfaceEXT, VKB_LEVEL_INSTANCE, "VK_EXT_headless_surface", 0},
|
|
{"vkCreateImage", (PFN_vkVoidFunction)vkb_ep_vkCreateImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateImageView", (PFN_vkVoidFunction)vkb_ep_vkCreateImageView, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateInstance", (PFN_vkVoidFunction)vkb_ep_vkCreateInstance, VKB_LEVEL_GLOBAL, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreatePipelineCache", (PFN_vkVoidFunction)vkb_ep_vkCreatePipelineCache, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreatePipelineLayout", (PFN_vkVoidFunction)vkb_ep_vkCreatePipelineLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreatePrivateDataSlot", (PFN_vkVoidFunction)vkb_ep_vkCreatePrivateDataSlot, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkCreatePrivateDataSlotEXT", (PFN_vkVoidFunction)vkb_ep_vkCreatePrivateDataSlot, VKB_LEVEL_DEVICE, "VK_EXT_private_data", 0},
|
|
{"vkCreateQueryPool", (PFN_vkVoidFunction)vkb_ep_vkCreateQueryPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateRenderPass", (PFN_vkVoidFunction)vkb_ep_vkCreateRenderPass, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateRenderPass2", (PFN_vkVoidFunction)vkb_ep_vkCreateRenderPass2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkCreateRenderPass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCreateRenderPass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2", 0},
|
|
{"vkCreateSampler", (PFN_vkVoidFunction)vkb_ep_vkCreateSampler, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateSamplerYcbcrConversion", (PFN_vkVoidFunction)vkb_ep_vkCreateSamplerYcbcrConversion, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkCreateSamplerYcbcrConversionKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateSamplerYcbcrConversion, VKB_LEVEL_DEVICE, "VK_KHR_sampler_ycbcr_conversion", 0},
|
|
{"vkCreateSemaphore", (PFN_vkVoidFunction)vkb_ep_vkCreateSemaphore, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateShaderModule", (PFN_vkVoidFunction)vkb_ep_vkCreateShaderModule, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkCreateSwapchainKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateSwapchainKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0},
|
|
{"vkCreateTensorARM", (PFN_vkVoidFunction)vkb_ep_vkCreateTensorARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0},
|
|
{"vkCreateTensorViewARM", (PFN_vkVoidFunction)vkb_ep_vkCreateTensorViewARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0},
|
|
{"vkCreateWaylandSurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateWaylandSurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_wayland_surface", 0},
|
|
{"vkCreateXcbSurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateXcbSurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_xcb_surface", 0},
|
|
{"vkCreateXlibSurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateXlibSurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_xlib_surface", 0},
|
|
{"vkDestroyBuffer", (PFN_vkVoidFunction)vkb_ep_vkDestroyBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyBufferView", (PFN_vkVoidFunction)vkb_ep_vkDestroyBufferView, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyCommandPool", (PFN_vkVoidFunction)vkb_ep_vkDestroyCommandPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyDebugUtilsMessengerEXT", (PFN_vkVoidFunction)vkb_ep_vkDestroyDebugUtilsMessengerEXT, VKB_LEVEL_INSTANCE, "VK_EXT_debug_utils", 0},
|
|
{"vkDestroyDescriptorPool", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyDescriptorSetLayout", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorSetLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyDescriptorUpdateTemplate", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkDestroyDescriptorUpdateTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, "VK_KHR_descriptor_update_template", 0},
|
|
{"vkDestroyDevice", (PFN_vkVoidFunction)vkb_ep_vkDestroyDevice, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyEvent", (PFN_vkVoidFunction)vkb_ep_vkDestroyEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyFence", (PFN_vkVoidFunction)vkb_ep_vkDestroyFence, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyFramebuffer", (PFN_vkVoidFunction)vkb_ep_vkDestroyFramebuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyImage", (PFN_vkVoidFunction)vkb_ep_vkDestroyImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyImageView", (PFN_vkVoidFunction)vkb_ep_vkDestroyImageView, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyInstance", (PFN_vkVoidFunction)vkb_ep_vkDestroyInstance, VKB_LEVEL_INSTANCE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyPipeline", (PFN_vkVoidFunction)vkb_ep_vkDestroyPipeline, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyPipelineCache", (PFN_vkVoidFunction)vkb_ep_vkDestroyPipelineCache, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyPipelineLayout", (PFN_vkVoidFunction)vkb_ep_vkDestroyPipelineLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyPrivateDataSlot", (PFN_vkVoidFunction)vkb_ep_vkDestroyPrivateDataSlot, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkDestroyPrivateDataSlotEXT", (PFN_vkVoidFunction)vkb_ep_vkDestroyPrivateDataSlot, VKB_LEVEL_DEVICE, "VK_EXT_private_data", 0},
|
|
{"vkDestroyQueryPool", (PFN_vkVoidFunction)vkb_ep_vkDestroyQueryPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyRenderPass", (PFN_vkVoidFunction)vkb_ep_vkDestroyRenderPass, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroySampler", (PFN_vkVoidFunction)vkb_ep_vkDestroySampler, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroySamplerYcbcrConversion", (PFN_vkVoidFunction)vkb_ep_vkDestroySamplerYcbcrConversion, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkDestroySamplerYcbcrConversionKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroySamplerYcbcrConversion, VKB_LEVEL_DEVICE, "VK_KHR_sampler_ycbcr_conversion", 0},
|
|
{"vkDestroySemaphore", (PFN_vkVoidFunction)vkb_ep_vkDestroySemaphore, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroyShaderModule", (PFN_vkVoidFunction)vkb_ep_vkDestroyShaderModule, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkDestroySurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroySurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_surface", 0},
|
|
{"vkDestroySwapchainKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroySwapchainKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0},
|
|
{"vkDestroyTensorARM", (PFN_vkVoidFunction)vkb_ep_vkDestroyTensorARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0},
|
|
{"vkDestroyTensorViewARM", (PFN_vkVoidFunction)vkb_ep_vkDestroyTensorViewARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0},
|
|
{"vkDeviceWaitIdle", (PFN_vkVoidFunction)vkb_ep_vkDeviceWaitIdle, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkEndCommandBuffer", (PFN_vkVoidFunction)vkb_ep_vkEndCommandBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkEnumerateDeviceExtensionProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateDeviceExtensionProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkEnumerateDeviceLayerProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateDeviceLayerProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkEnumerateInstanceExtensionProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateInstanceExtensionProperties, VKB_LEVEL_GLOBAL, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkEnumerateInstanceLayerProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateInstanceLayerProperties, VKB_LEVEL_GLOBAL, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkEnumerateInstanceVersion", (PFN_vkVoidFunction)vkb_ep_vkEnumerateInstanceVersion, VKB_LEVEL_GLOBAL, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkEnumeratePhysicalDeviceGroups", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDeviceGroups, VKB_LEVEL_INSTANCE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkEnumeratePhysicalDeviceGroupsKHR", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDeviceGroups, VKB_LEVEL_INSTANCE, "VK_KHR_device_group_creation", 0},
|
|
{"vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, VKB_LEVEL_PHYSDEV, "VK_ARM_performance_counters_by_region", 0},
|
|
{"vkEnumeratePhysicalDevices", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDevices, VKB_LEVEL_INSTANCE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkFlushMappedMemoryRanges", (PFN_vkVoidFunction)vkb_ep_vkFlushMappedMemoryRanges, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkFreeCommandBuffers", (PFN_vkVoidFunction)vkb_ep_vkFreeCommandBuffers, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkFreeDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkFreeDescriptorSets, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkFreeMemory", (PFN_vkVoidFunction)vkb_ep_vkFreeMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetBufferDeviceAddress", (PFN_vkVoidFunction)vkb_ep_vkGetBufferDeviceAddress, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkGetBufferDeviceAddressEXT", (PFN_vkVoidFunction)vkb_ep_vkGetBufferDeviceAddress, VKB_LEVEL_DEVICE, "VK_EXT_buffer_device_address", 0},
|
|
{"vkGetBufferDeviceAddressKHR", (PFN_vkVoidFunction)vkb_ep_vkGetBufferDeviceAddress, VKB_LEVEL_DEVICE, "VK_KHR_buffer_device_address", 0},
|
|
{"vkGetBufferMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetBufferMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetBufferMemoryRequirements2", (PFN_vkVoidFunction)vkb_ep_vkGetBufferMemoryRequirements2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetBufferMemoryRequirements2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetBufferMemoryRequirements2, VKB_LEVEL_DEVICE, "VK_KHR_get_memory_requirements2", 0},
|
|
{"vkGetBufferOpaqueCaptureAddress", (PFN_vkVoidFunction)vkb_ep_vkGetBufferOpaqueCaptureAddress, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkGetBufferOpaqueCaptureAddressKHR", (PFN_vkVoidFunction)vkb_ep_vkGetBufferOpaqueCaptureAddress, VKB_LEVEL_DEVICE, "VK_KHR_buffer_device_address", 0},
|
|
{"vkGetCalibratedTimestampsEXT", (PFN_vkVoidFunction)vkb_ep_vkGetCalibratedTimestampsKHR, VKB_LEVEL_DEVICE, "VK_EXT_calibrated_timestamps", 0},
|
|
{"vkGetCalibratedTimestampsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetCalibratedTimestampsKHR, VKB_LEVEL_DEVICE, "VK_EXT_calibrated_timestamps", 0},
|
|
{"vkGetDescriptorSetLayoutSupport", (PFN_vkVoidFunction)vkb_ep_vkGetDescriptorSetLayoutSupport, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetDescriptorSetLayoutSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDescriptorSetLayoutSupport, VKB_LEVEL_DEVICE, "VK_KHR_maintenance3", 0},
|
|
{"vkGetDeviceBufferMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceBufferMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkGetDeviceBufferMemoryRequirementsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceBufferMemoryRequirements, VKB_LEVEL_DEVICE, "VK_KHR_maintenance4", 0},
|
|
{"vkGetDeviceGroupPeerMemoryFeatures", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupPeerMemoryFeatures, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetDeviceGroupPeerMemoryFeaturesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupPeerMemoryFeatures, VKB_LEVEL_DEVICE, "VK_KHR_device_group", 0},
|
|
{"vkGetDeviceGroupPresentCapabilitiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupPresentCapabilitiesKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0},
|
|
{"vkGetDeviceGroupSurfacePresentModesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupSurfacePresentModesKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0},
|
|
{"vkGetDeviceImageMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkGetDeviceImageMemoryRequirementsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageMemoryRequirements, VKB_LEVEL_DEVICE, "VK_KHR_maintenance4", 0},
|
|
{"vkGetDeviceImageSparseMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSparseMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkGetDeviceImageSparseMemoryRequirementsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSparseMemoryRequirements, VKB_LEVEL_DEVICE, "VK_KHR_maintenance4", 0},
|
|
{"vkGetDeviceImageSubresourceLayout", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSubresourceLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkGetDeviceImageSubresourceLayoutKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSubresourceLayout, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5", 0},
|
|
{"vkGetDeviceMemoryCommitment", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceMemoryCommitment, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetDeviceMemoryOpaqueCaptureAddress", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceMemoryOpaqueCaptureAddress, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkGetDeviceMemoryOpaqueCaptureAddressKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceMemoryOpaqueCaptureAddress, VKB_LEVEL_DEVICE, "VK_KHR_buffer_device_address", 0},
|
|
{"vkGetDeviceProcAddr", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceProcAddr, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetDeviceQueue", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceQueue, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetDeviceQueue2", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceQueue2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetDeviceTensorMemoryRequirementsARM", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceTensorMemoryRequirementsARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0},
|
|
{"vkGetEventStatus", (PFN_vkVoidFunction)vkb_ep_vkGetEventStatus, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetFenceFdKHR", (PFN_vkVoidFunction)vkb_ep_vkGetFenceFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_fence_fd", 0},
|
|
{"vkGetFenceStatus", (PFN_vkVoidFunction)vkb_ep_vkGetFenceStatus, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetImageDrmFormatModifierPropertiesEXT", (PFN_vkVoidFunction)vkb_ep_vkGetImageDrmFormatModifierPropertiesEXT, VKB_LEVEL_DEVICE, "VK_EXT_image_drm_format_modifier", 0},
|
|
{"vkGetImageMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetImageMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetImageMemoryRequirements2", (PFN_vkVoidFunction)vkb_ep_vkGetImageMemoryRequirements2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetImageMemoryRequirements2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetImageMemoryRequirements2, VKB_LEVEL_DEVICE, "VK_KHR_get_memory_requirements2", 0},
|
|
{"vkGetImageSparseMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetImageSparseMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetImageSparseMemoryRequirements2", (PFN_vkVoidFunction)vkb_ep_vkGetImageSparseMemoryRequirements2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetImageSparseMemoryRequirements2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetImageSparseMemoryRequirements2, VKB_LEVEL_DEVICE, "VK_KHR_get_memory_requirements2", 0},
|
|
{"vkGetImageSubresourceLayout", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetImageSubresourceLayout2", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkGetImageSubresourceLayout2EXT", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout2, VKB_LEVEL_DEVICE, "VK_EXT_image_compression_control", 0},
|
|
{"vkGetImageSubresourceLayout2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5", 0},
|
|
{"vkGetInstanceProcAddr", (PFN_vkVoidFunction)vkb_ep_vkGetInstanceProcAddr, VKB_LEVEL_INSTANCE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetMemoryFdKHR", (PFN_vkVoidFunction)vkb_ep_vkGetMemoryFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_memory_fd", 0},
|
|
{"vkGetMemoryFdPropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetMemoryFdPropertiesKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_memory_fd", 0},
|
|
{"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, VKB_LEVEL_PHYSDEV, "VK_EXT_calibrated_timestamps", 0},
|
|
{"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, VKB_LEVEL_PHYSDEV, "VK_EXT_calibrated_timestamps", 0},
|
|
{"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_cooperative_matrix", 0},
|
|
{"vkGetPhysicalDeviceExternalBufferProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalBufferProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalBufferProperties, VKB_LEVEL_PHYSDEV, "VK_KHR_external_memory_capabilities", 0},
|
|
{"vkGetPhysicalDeviceExternalFenceProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalFenceProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetPhysicalDeviceExternalFencePropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalFenceProperties, VKB_LEVEL_PHYSDEV, "VK_KHR_external_fence_capabilities", 0},
|
|
{"vkGetPhysicalDeviceExternalSemaphoreProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalSemaphoreProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalSemaphoreProperties, VKB_LEVEL_PHYSDEV, "VK_KHR_external_semaphore_capabilities", 0},
|
|
{"vkGetPhysicalDeviceExternalTensorPropertiesARM", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalTensorPropertiesARM, VKB_LEVEL_PHYSDEV, "VK_ARM_tensors", 0},
|
|
{"vkGetPhysicalDeviceFeatures", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFeatures, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetPhysicalDeviceFeatures2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFeatures2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetPhysicalDeviceFeatures2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFeatures2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0},
|
|
{"vkGetPhysicalDeviceFormatProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFormatProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetPhysicalDeviceFormatProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFormatProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetPhysicalDeviceFormatProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFormatProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0},
|
|
{"vkGetPhysicalDeviceFragmentShadingRatesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFragmentShadingRatesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_fragment_shading_rate", 0},
|
|
{"vkGetPhysicalDeviceImageFormatProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceImageFormatProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetPhysicalDeviceImageFormatProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceImageFormatProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetPhysicalDeviceImageFormatProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceImageFormatProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0},
|
|
{"vkGetPhysicalDeviceMemoryProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMemoryProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetPhysicalDeviceMemoryProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMemoryProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetPhysicalDeviceMemoryProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMemoryProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0},
|
|
{"vkGetPhysicalDeviceMultisamplePropertiesEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMultisamplePropertiesEXT, VKB_LEVEL_PHYSDEV, "VK_EXT_sample_locations", 0},
|
|
{"vkGetPhysicalDevicePresentRectanglesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDevicePresentRectanglesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_swapchain", 0},
|
|
{"vkGetPhysicalDeviceProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetPhysicalDeviceProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetPhysicalDeviceProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0},
|
|
{"vkGetPhysicalDeviceQueueFamilyProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetPhysicalDeviceQueueFamilyProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0},
|
|
{"vkGetPhysicalDeviceSparseImageFormatProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetPhysicalDeviceSparseImageFormatProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0},
|
|
{"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceCapabilities2KHR, VKB_LEVEL_PHYSDEV, "VK_KHR_get_surface_capabilities2", 0},
|
|
{"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface", 0},
|
|
{"vkGetPhysicalDeviceSurfaceFormats2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceFormats2KHR, VKB_LEVEL_PHYSDEV, "VK_KHR_get_surface_capabilities2", 0},
|
|
{"vkGetPhysicalDeviceSurfaceFormatsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceFormatsKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface", 0},
|
|
{"vkGetPhysicalDeviceSurfacePresentModesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfacePresentModesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface", 0},
|
|
{"vkGetPhysicalDeviceSurfaceSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface", 0},
|
|
{"vkGetPhysicalDeviceToolProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceToolProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkGetPhysicalDeviceToolPropertiesEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceToolProperties, VKB_LEVEL_PHYSDEV, "VK_EXT_tooling_info", 0},
|
|
{"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceWaylandPresentationSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_wayland_surface", 0},
|
|
{"vkGetPhysicalDeviceXcbPresentationSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceXcbPresentationSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_xcb_surface", 0},
|
|
{"vkGetPhysicalDeviceXlibPresentationSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceXlibPresentationSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_xlib_surface", 0},
|
|
{"vkGetPipelineCacheData", (PFN_vkVoidFunction)vkb_ep_vkGetPipelineCacheData, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetPrivateData", (PFN_vkVoidFunction)vkb_ep_vkGetPrivateData, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkGetPrivateDataEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPrivateData, VKB_LEVEL_DEVICE, "VK_EXT_private_data", 0},
|
|
{"vkGetQueryPoolResults", (PFN_vkVoidFunction)vkb_ep_vkGetQueryPoolResults, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetRenderAreaGranularity", (PFN_vkVoidFunction)vkb_ep_vkGetRenderAreaGranularity, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkGetRenderingAreaGranularity", (PFN_vkVoidFunction)vkb_ep_vkGetRenderingAreaGranularity, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkGetRenderingAreaGranularityKHR", (PFN_vkVoidFunction)vkb_ep_vkGetRenderingAreaGranularity, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5", 0},
|
|
{"vkGetSemaphoreCounterValue", (PFN_vkVoidFunction)vkb_ep_vkGetSemaphoreCounterValue, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkGetSemaphoreCounterValueKHR", (PFN_vkVoidFunction)vkb_ep_vkGetSemaphoreCounterValue, VKB_LEVEL_DEVICE, "VK_KHR_timeline_semaphore", 0},
|
|
{"vkGetSemaphoreFdKHR", (PFN_vkVoidFunction)vkb_ep_vkGetSemaphoreFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_semaphore_fd", 0},
|
|
{"vkGetShaderModuleCreateInfoIdentifierEXT", (PFN_vkVoidFunction)vkb_ep_vkGetShaderModuleCreateInfoIdentifierEXT, VKB_LEVEL_DEVICE, "VK_EXT_shader_module_identifier", 0},
|
|
{"vkGetShaderModuleIdentifierEXT", (PFN_vkVoidFunction)vkb_ep_vkGetShaderModuleIdentifierEXT, VKB_LEVEL_DEVICE, "VK_EXT_shader_module_identifier", 0},
|
|
{"vkGetSwapchainImagesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetSwapchainImagesKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0},
|
|
{"vkGetTensorMemoryRequirementsARM", (PFN_vkVoidFunction)vkb_ep_vkGetTensorMemoryRequirementsARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0},
|
|
{"vkImportFenceFdKHR", (PFN_vkVoidFunction)vkb_ep_vkImportFenceFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_fence_fd", 0},
|
|
{"vkImportSemaphoreFdKHR", (PFN_vkVoidFunction)vkb_ep_vkImportSemaphoreFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_semaphore_fd", 0},
|
|
{"vkInvalidateMappedMemoryRanges", (PFN_vkVoidFunction)vkb_ep_vkInvalidateMappedMemoryRanges, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkMapMemory", (PFN_vkVoidFunction)vkb_ep_vkMapMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkMapMemory2", (PFN_vkVoidFunction)vkb_ep_vkMapMemory2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkMapMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkMapMemory2, VKB_LEVEL_DEVICE, "VK_KHR_map_memory2", 0},
|
|
{"vkMergePipelineCaches", (PFN_vkVoidFunction)vkb_ep_vkMergePipelineCaches, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkQueueBeginDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkQueueBeginDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0},
|
|
{"vkQueueBindSparse", (PFN_vkVoidFunction)vkb_ep_vkQueueBindSparse, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkQueueEndDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkQueueEndDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0},
|
|
{"vkQueueInsertDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkQueueInsertDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0},
|
|
{"vkQueuePresentKHR", (PFN_vkVoidFunction)vkb_ep_vkQueuePresentKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0},
|
|
{"vkQueueSubmit", (PFN_vkVoidFunction)vkb_ep_vkQueueSubmit, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkQueueSubmit2", (PFN_vkVoidFunction)vkb_ep_vkQueueSubmit2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkQueueSubmit2KHR", (PFN_vkVoidFunction)vkb_ep_vkQueueSubmit2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0},
|
|
{"vkQueueWaitIdle", (PFN_vkVoidFunction)vkb_ep_vkQueueWaitIdle, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkResetCommandBuffer", (PFN_vkVoidFunction)vkb_ep_vkResetCommandBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkResetCommandPool", (PFN_vkVoidFunction)vkb_ep_vkResetCommandPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkResetDescriptorPool", (PFN_vkVoidFunction)vkb_ep_vkResetDescriptorPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkResetEvent", (PFN_vkVoidFunction)vkb_ep_vkResetEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkResetFences", (PFN_vkVoidFunction)vkb_ep_vkResetFences, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkResetQueryPool", (PFN_vkVoidFunction)vkb_ep_vkResetQueryPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkResetQueryPoolEXT", (PFN_vkVoidFunction)vkb_ep_vkResetQueryPool, VKB_LEVEL_DEVICE, "VK_EXT_host_query_reset", 0},
|
|
{"vkSetDebugUtilsObjectNameEXT", (PFN_vkVoidFunction)vkb_ep_vkSetDebugUtilsObjectNameEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0},
|
|
{"vkSetDebugUtilsObjectTagEXT", (PFN_vkVoidFunction)vkb_ep_vkSetDebugUtilsObjectTagEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0},
|
|
{"vkSetDeviceMemoryPriorityEXT", (PFN_vkVoidFunction)vkb_ep_vkSetDeviceMemoryPriorityEXT, VKB_LEVEL_DEVICE, "VK_EXT_pageable_device_local_memory", 0},
|
|
{"vkSetEvent", (PFN_vkVoidFunction)vkb_ep_vkSetEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkSetPrivateData", (PFN_vkVoidFunction)vkb_ep_vkSetPrivateData, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)},
|
|
{"vkSetPrivateDataEXT", (PFN_vkVoidFunction)vkb_ep_vkSetPrivateData, VKB_LEVEL_DEVICE, "VK_EXT_private_data", 0},
|
|
{"vkSignalSemaphore", (PFN_vkVoidFunction)vkb_ep_vkSignalSemaphore, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkSignalSemaphoreKHR", (PFN_vkVoidFunction)vkb_ep_vkSignalSemaphore, VKB_LEVEL_DEVICE, "VK_KHR_timeline_semaphore", 0},
|
|
{"vkSubmitDebugUtilsMessageEXT", (PFN_vkVoidFunction)vkb_ep_vkSubmitDebugUtilsMessageEXT, VKB_LEVEL_INSTANCE, "VK_EXT_debug_utils", 0},
|
|
{"vkTransitionImageLayout", (PFN_vkVoidFunction)vkb_ep_vkTransitionImageLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkTransitionImageLayoutEXT", (PFN_vkVoidFunction)vkb_ep_vkTransitionImageLayout, VKB_LEVEL_DEVICE, NULL, 0},
|
|
{"vkTrimCommandPool", (PFN_vkVoidFunction)vkb_ep_vkTrimCommandPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkTrimCommandPoolKHR", (PFN_vkVoidFunction)vkb_ep_vkTrimCommandPool, VKB_LEVEL_DEVICE, "VK_KHR_maintenance1", 0},
|
|
{"vkUnmapMemory", (PFN_vkVoidFunction)vkb_ep_vkUnmapMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkUnmapMemory2", (PFN_vkVoidFunction)vkb_ep_vkUnmapMemory2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)},
|
|
{"vkUnmapMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkUnmapMemory2, VKB_LEVEL_DEVICE, "VK_KHR_map_memory2", 0},
|
|
{"vkUpdateDescriptorSetWithTemplate", (PFN_vkVoidFunction)vkb_ep_vkUpdateDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)},
|
|
{"vkUpdateDescriptorSetWithTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkUpdateDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, "VK_KHR_descriptor_update_template", 0},
|
|
{"vkUpdateDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkUpdateDescriptorSets, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkWaitForFences", (PFN_vkVoidFunction)vkb_ep_vkWaitForFences, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)},
|
|
{"vkWaitSemaphores", (PFN_vkVoidFunction)vkb_ep_vkWaitSemaphores, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)},
|
|
{"vkWaitSemaphoresKHR", (PFN_vkVoidFunction)vkb_ep_vkWaitSemaphores, VKB_LEVEL_DEVICE, "VK_KHR_timeline_semaphore", 0},
|
|
};
|
|
const size_t vkb_client_proc_count = sizeof(vkb_client_procs) / sizeof(vkb_client_procs[0]);
|