2021-04-16 15:48:48 +02:00
|
|
|
/* Automatically generated from Vulkan vk.xml; DO NOT EDIT!
|
|
|
|
*
|
|
|
|
* This file is generated from Vulkan vk.xml file covered
|
|
|
|
* by the following copyright and permission notice:
|
|
|
|
*
|
|
|
|
* Copyright 2015-2021 The Khronos Group Inc.
|
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2021-04-19 14:14:59 +02:00
|
|
|
#include "vulkan_loader.h"
|
2021-04-16 15:48:48 +02:00
|
|
|
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkAcquireNextImage2KHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pAcquireInfo = pAcquireInfo;
|
|
|
|
params.pImageIndex = pImageIndex;
|
|
|
|
return unix_funcs->p_vkAcquireNextImage2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkAcquireNextImageKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.swapchain = swapchain;
|
|
|
|
params.timeout = timeout;
|
|
|
|
params.semaphore = semaphore;
|
|
|
|
params.fence = fence;
|
|
|
|
params.pImageIndex = pImageIndex;
|
|
|
|
return unix_funcs->p_vkAcquireNextImageKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkAcquirePerformanceConfigurationINTEL_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pAcquireInfo = pAcquireInfo;
|
|
|
|
params.pConfiguration = pConfiguration;
|
|
|
|
return unix_funcs->p_vkAcquirePerformanceConfigurationINTEL(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkAcquireProfilingLockKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
return unix_funcs->p_vkAcquireProfilingLockKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkAllocateCommandBuffers_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pAllocateInfo = pAllocateInfo;
|
|
|
|
params.pCommandBuffers = pCommandBuffers;
|
|
|
|
return unix_funcs->p_vkAllocateCommandBuffers(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkAllocateDescriptorSets_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pAllocateInfo = pAllocateInfo;
|
|
|
|
params.pDescriptorSets = pDescriptorSets;
|
|
|
|
return unix_funcs->p_vkAllocateDescriptorSets(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkAllocateMemory_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pAllocateInfo = pAllocateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pMemory = pMemory;
|
|
|
|
return unix_funcs->p_vkAllocateMemory(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkBeginCommandBuffer_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pBeginInfo = pBeginInfo;
|
|
|
|
return unix_funcs->p_vkBeginCommandBuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkBindAccelerationStructureMemoryNV_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.bindInfoCount = bindInfoCount;
|
|
|
|
params.pBindInfos = pBindInfos;
|
|
|
|
return unix_funcs->p_vkBindAccelerationStructureMemoryNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkBindBufferMemory_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.memory = memory;
|
|
|
|
params.memoryOffset = memoryOffset;
|
|
|
|
return unix_funcs->p_vkBindBufferMemory(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkBindBufferMemory2_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.bindInfoCount = bindInfoCount;
|
|
|
|
params.pBindInfos = pBindInfos;
|
|
|
|
return unix_funcs->p_vkBindBufferMemory2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkBindBufferMemory2KHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.bindInfoCount = bindInfoCount;
|
|
|
|
params.pBindInfos = pBindInfos;
|
|
|
|
return unix_funcs->p_vkBindBufferMemory2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkBindImageMemory_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.image = image;
|
|
|
|
params.memory = memory;
|
|
|
|
params.memoryOffset = memoryOffset;
|
|
|
|
return unix_funcs->p_vkBindImageMemory(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkBindImageMemory2_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.bindInfoCount = bindInfoCount;
|
|
|
|
params.pBindInfos = pBindInfos;
|
|
|
|
return unix_funcs->p_vkBindImageMemory2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkBindImageMemory2KHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.bindInfoCount = bindInfoCount;
|
|
|
|
params.pBindInfos = pBindInfos;
|
|
|
|
return unix_funcs->p_vkBindImageMemory2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkBuildAccelerationStructuresKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.deferredOperation = deferredOperation;
|
|
|
|
params.infoCount = infoCount;
|
|
|
|
params.pInfos = pInfos;
|
|
|
|
params.ppBuildRangeInfos = ppBuildRangeInfos;
|
|
|
|
return unix_funcs->p_vkBuildAccelerationStructuresKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBeginConditionalRenderingEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pConditionalRenderingBegin = pConditionalRenderingBegin;
|
|
|
|
unix_funcs->p_vkCmdBeginConditionalRenderingEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBeginDebugUtilsLabelEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pLabelInfo = pLabelInfo;
|
|
|
|
unix_funcs->p_vkCmdBeginDebugUtilsLabelEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBeginQuery_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.query = query;
|
|
|
|
params.flags = flags;
|
|
|
|
unix_funcs->p_vkCmdBeginQuery(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBeginQueryIndexedEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.query = query;
|
|
|
|
params.flags = flags;
|
|
|
|
params.index = index;
|
|
|
|
unix_funcs->p_vkCmdBeginQueryIndexedEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBeginRenderPass_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pRenderPassBegin = pRenderPassBegin;
|
|
|
|
params.contents = contents;
|
|
|
|
unix_funcs->p_vkCmdBeginRenderPass(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBeginRenderPass2_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pRenderPassBegin = pRenderPassBegin;
|
|
|
|
params.pSubpassBeginInfo = pSubpassBeginInfo;
|
|
|
|
unix_funcs->p_vkCmdBeginRenderPass2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBeginRenderPass2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pRenderPassBegin = pRenderPassBegin;
|
|
|
|
params.pSubpassBeginInfo = pSubpassBeginInfo;
|
|
|
|
unix_funcs->p_vkCmdBeginRenderPass2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-11-02 11:59:57 +01:00
|
|
|
void WINAPI vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR *pRenderingInfo)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBeginRenderingKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pRenderingInfo = pRenderingInfo;
|
|
|
|
unix_funcs->p_vkCmdBeginRenderingKHR(¶ms);
|
2021-11-02 11:59:57 +01:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBeginTransformFeedbackEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.firstCounterBuffer = firstCounterBuffer;
|
|
|
|
params.counterBufferCount = counterBufferCount;
|
|
|
|
params.pCounterBuffers = pCounterBuffers;
|
|
|
|
params.pCounterBufferOffsets = pCounterBufferOffsets;
|
|
|
|
unix_funcs->p_vkCmdBeginTransformFeedbackEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBindDescriptorSets_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pipelineBindPoint = pipelineBindPoint;
|
|
|
|
params.layout = layout;
|
|
|
|
params.firstSet = firstSet;
|
|
|
|
params.descriptorSetCount = descriptorSetCount;
|
|
|
|
params.pDescriptorSets = pDescriptorSets;
|
|
|
|
params.dynamicOffsetCount = dynamicOffsetCount;
|
|
|
|
params.pDynamicOffsets = pDynamicOffsets;
|
|
|
|
unix_funcs->p_vkCmdBindDescriptorSets(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBindIndexBuffer_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
params.indexType = indexType;
|
|
|
|
unix_funcs->p_vkCmdBindIndexBuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-07-20 15:04:48 +02:00
|
|
|
void WINAPI vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBindInvocationMaskHUAWEI_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.imageView = imageView;
|
|
|
|
params.imageLayout = imageLayout;
|
|
|
|
unix_funcs->p_vkCmdBindInvocationMaskHUAWEI(¶ms);
|
2021-07-20 15:04:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBindPipeline_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pipelineBindPoint = pipelineBindPoint;
|
|
|
|
params.pipeline = pipeline;
|
|
|
|
unix_funcs->p_vkCmdBindPipeline(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBindPipelineShaderGroupNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pipelineBindPoint = pipelineBindPoint;
|
|
|
|
params.pipeline = pipeline;
|
|
|
|
params.groupIndex = groupIndex;
|
|
|
|
unix_funcs->p_vkCmdBindPipelineShaderGroupNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBindShadingRateImageNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.imageView = imageView;
|
|
|
|
params.imageLayout = imageLayout;
|
|
|
|
unix_funcs->p_vkCmdBindShadingRateImageNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBindTransformFeedbackBuffersEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.firstBinding = firstBinding;
|
|
|
|
params.bindingCount = bindingCount;
|
|
|
|
params.pBuffers = pBuffers;
|
|
|
|
params.pOffsets = pOffsets;
|
|
|
|
params.pSizes = pSizes;
|
|
|
|
unix_funcs->p_vkCmdBindTransformFeedbackBuffersEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBindVertexBuffers_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.firstBinding = firstBinding;
|
|
|
|
params.bindingCount = bindingCount;
|
|
|
|
params.pBuffers = pBuffers;
|
|
|
|
params.pOffsets = pOffsets;
|
|
|
|
unix_funcs->p_vkCmdBindVertexBuffers(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBindVertexBuffers2EXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.firstBinding = firstBinding;
|
|
|
|
params.bindingCount = bindingCount;
|
|
|
|
params.pBuffers = pBuffers;
|
|
|
|
params.pOffsets = pOffsets;
|
|
|
|
params.pSizes = pSizes;
|
|
|
|
params.pStrides = pStrides;
|
|
|
|
unix_funcs->p_vkCmdBindVertexBuffers2EXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBlitImage_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.srcImage = srcImage;
|
|
|
|
params.srcImageLayout = srcImageLayout;
|
|
|
|
params.dstImage = dstImage;
|
|
|
|
params.dstImageLayout = dstImageLayout;
|
|
|
|
params.regionCount = regionCount;
|
|
|
|
params.pRegions = pRegions;
|
|
|
|
params.filter = filter;
|
|
|
|
unix_funcs->p_vkCmdBlitImage(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBlitImage2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pBlitImageInfo = pBlitImageInfo;
|
|
|
|
unix_funcs->p_vkCmdBlitImage2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBuildAccelerationStructureNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.instanceData = instanceData;
|
|
|
|
params.instanceOffset = instanceOffset;
|
|
|
|
params.update = update;
|
|
|
|
params.dst = dst;
|
|
|
|
params.src = src;
|
|
|
|
params.scratch = scratch;
|
|
|
|
params.scratchOffset = scratchOffset;
|
|
|
|
unix_funcs->p_vkCmdBuildAccelerationStructureNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t * const*ppMaxPrimitiveCounts)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBuildAccelerationStructuresIndirectKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.infoCount = infoCount;
|
|
|
|
params.pInfos = pInfos;
|
|
|
|
params.pIndirectDeviceAddresses = pIndirectDeviceAddresses;
|
|
|
|
params.pIndirectStrides = pIndirectStrides;
|
|
|
|
params.ppMaxPrimitiveCounts = ppMaxPrimitiveCounts;
|
|
|
|
unix_funcs->p_vkCmdBuildAccelerationStructuresIndirectKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdBuildAccelerationStructuresKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.infoCount = infoCount;
|
|
|
|
params.pInfos = pInfos;
|
|
|
|
params.ppBuildRangeInfos = ppBuildRangeInfos;
|
|
|
|
unix_funcs->p_vkCmdBuildAccelerationStructuresKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdClearAttachments_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.attachmentCount = attachmentCount;
|
|
|
|
params.pAttachments = pAttachments;
|
|
|
|
params.rectCount = rectCount;
|
|
|
|
params.pRects = pRects;
|
|
|
|
unix_funcs->p_vkCmdClearAttachments(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdClearColorImage_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.image = image;
|
|
|
|
params.imageLayout = imageLayout;
|
|
|
|
params.pColor = pColor;
|
|
|
|
params.rangeCount = rangeCount;
|
|
|
|
params.pRanges = pRanges;
|
|
|
|
unix_funcs->p_vkCmdClearColorImage(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdClearDepthStencilImage_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.image = image;
|
|
|
|
params.imageLayout = imageLayout;
|
|
|
|
params.pDepthStencil = pDepthStencil;
|
|
|
|
params.rangeCount = rangeCount;
|
|
|
|
params.pRanges = pRanges;
|
|
|
|
unix_funcs->p_vkCmdClearDepthStencilImage(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyAccelerationStructureKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
unix_funcs->p_vkCmdCopyAccelerationStructureKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyAccelerationStructureNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.dst = dst;
|
|
|
|
params.src = src;
|
|
|
|
params.mode = mode;
|
|
|
|
unix_funcs->p_vkCmdCopyAccelerationStructureNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyAccelerationStructureToMemoryKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
unix_funcs->p_vkCmdCopyAccelerationStructureToMemoryKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyBuffer_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.srcBuffer = srcBuffer;
|
|
|
|
params.dstBuffer = dstBuffer;
|
|
|
|
params.regionCount = regionCount;
|
|
|
|
params.pRegions = pRegions;
|
|
|
|
unix_funcs->p_vkCmdCopyBuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyBuffer2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pCopyBufferInfo = pCopyBufferInfo;
|
|
|
|
unix_funcs->p_vkCmdCopyBuffer2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyBufferToImage_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.srcBuffer = srcBuffer;
|
|
|
|
params.dstImage = dstImage;
|
|
|
|
params.dstImageLayout = dstImageLayout;
|
|
|
|
params.regionCount = regionCount;
|
|
|
|
params.pRegions = pRegions;
|
|
|
|
unix_funcs->p_vkCmdCopyBufferToImage(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyBufferToImage2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pCopyBufferToImageInfo = pCopyBufferToImageInfo;
|
|
|
|
unix_funcs->p_vkCmdCopyBufferToImage2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyImage_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.srcImage = srcImage;
|
|
|
|
params.srcImageLayout = srcImageLayout;
|
|
|
|
params.dstImage = dstImage;
|
|
|
|
params.dstImageLayout = dstImageLayout;
|
|
|
|
params.regionCount = regionCount;
|
|
|
|
params.pRegions = pRegions;
|
|
|
|
unix_funcs->p_vkCmdCopyImage(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyImage2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pCopyImageInfo = pCopyImageInfo;
|
|
|
|
unix_funcs->p_vkCmdCopyImage2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyImageToBuffer_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.srcImage = srcImage;
|
|
|
|
params.srcImageLayout = srcImageLayout;
|
|
|
|
params.dstBuffer = dstBuffer;
|
|
|
|
params.regionCount = regionCount;
|
|
|
|
params.pRegions = pRegions;
|
|
|
|
unix_funcs->p_vkCmdCopyImageToBuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyImageToBuffer2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pCopyImageToBufferInfo = pCopyImageToBufferInfo;
|
|
|
|
unix_funcs->p_vkCmdCopyImageToBuffer2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyMemoryToAccelerationStructureKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
unix_funcs->p_vkCmdCopyMemoryToAccelerationStructureKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCopyQueryPoolResults_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.firstQuery = firstQuery;
|
|
|
|
params.queryCount = queryCount;
|
|
|
|
params.dstBuffer = dstBuffer;
|
|
|
|
params.dstOffset = dstOffset;
|
|
|
|
params.stride = stride;
|
|
|
|
params.flags = flags;
|
|
|
|
unix_funcs->p_vkCmdCopyQueryPoolResults(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-05-10 12:29:08 +02:00
|
|
|
void WINAPI vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdCuLaunchKernelNVX_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pLaunchInfo = pLaunchInfo;
|
|
|
|
unix_funcs->p_vkCmdCuLaunchKernelNVX(¶ms);
|
2021-05-10 12:29:08 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDebugMarkerBeginEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pMarkerInfo = pMarkerInfo;
|
|
|
|
unix_funcs->p_vkCmdDebugMarkerBeginEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDebugMarkerEndEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
unix_funcs->p_vkCmdDebugMarkerEndEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDebugMarkerInsertEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pMarkerInfo = pMarkerInfo;
|
|
|
|
unix_funcs->p_vkCmdDebugMarkerInsertEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDispatch_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.groupCountX = groupCountX;
|
|
|
|
params.groupCountY = groupCountY;
|
|
|
|
params.groupCountZ = groupCountZ;
|
|
|
|
unix_funcs->p_vkCmdDispatch(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDispatchBase_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.baseGroupX = baseGroupX;
|
|
|
|
params.baseGroupY = baseGroupY;
|
|
|
|
params.baseGroupZ = baseGroupZ;
|
|
|
|
params.groupCountX = groupCountX;
|
|
|
|
params.groupCountY = groupCountY;
|
|
|
|
params.groupCountZ = groupCountZ;
|
|
|
|
unix_funcs->p_vkCmdDispatchBase(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDispatchBaseKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.baseGroupX = baseGroupX;
|
|
|
|
params.baseGroupY = baseGroupY;
|
|
|
|
params.baseGroupZ = baseGroupZ;
|
|
|
|
params.groupCountX = groupCountX;
|
|
|
|
params.groupCountY = groupCountY;
|
|
|
|
params.groupCountZ = groupCountZ;
|
|
|
|
unix_funcs->p_vkCmdDispatchBaseKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDispatchIndirect_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
unix_funcs->p_vkCmdDispatchIndirect(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDraw_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.vertexCount = vertexCount;
|
|
|
|
params.instanceCount = instanceCount;
|
|
|
|
params.firstVertex = firstVertex;
|
|
|
|
params.firstInstance = firstInstance;
|
|
|
|
unix_funcs->p_vkCmdDraw(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawIndexed_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.indexCount = indexCount;
|
|
|
|
params.instanceCount = instanceCount;
|
|
|
|
params.firstIndex = firstIndex;
|
|
|
|
params.vertexOffset = vertexOffset;
|
|
|
|
params.firstInstance = firstInstance;
|
|
|
|
unix_funcs->p_vkCmdDrawIndexed(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawIndexedIndirect_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
params.drawCount = drawCount;
|
|
|
|
params.stride = stride;
|
|
|
|
unix_funcs->p_vkCmdDrawIndexedIndirect(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawIndexedIndirectCount_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
params.countBuffer = countBuffer;
|
|
|
|
params.countBufferOffset = countBufferOffset;
|
|
|
|
params.maxDrawCount = maxDrawCount;
|
|
|
|
params.stride = stride;
|
|
|
|
unix_funcs->p_vkCmdDrawIndexedIndirectCount(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawIndexedIndirectCountAMD_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
params.countBuffer = countBuffer;
|
|
|
|
params.countBufferOffset = countBufferOffset;
|
|
|
|
params.maxDrawCount = maxDrawCount;
|
|
|
|
params.stride = stride;
|
|
|
|
unix_funcs->p_vkCmdDrawIndexedIndirectCountAMD(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawIndexedIndirectCountKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
params.countBuffer = countBuffer;
|
|
|
|
params.countBufferOffset = countBufferOffset;
|
|
|
|
params.maxDrawCount = maxDrawCount;
|
|
|
|
params.stride = stride;
|
|
|
|
unix_funcs->p_vkCmdDrawIndexedIndirectCountKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawIndirect_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
params.drawCount = drawCount;
|
|
|
|
params.stride = stride;
|
|
|
|
unix_funcs->p_vkCmdDrawIndirect(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawIndirectByteCountEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.instanceCount = instanceCount;
|
|
|
|
params.firstInstance = firstInstance;
|
|
|
|
params.counterBuffer = counterBuffer;
|
|
|
|
params.counterBufferOffset = counterBufferOffset;
|
|
|
|
params.counterOffset = counterOffset;
|
|
|
|
params.vertexStride = vertexStride;
|
|
|
|
unix_funcs->p_vkCmdDrawIndirectByteCountEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawIndirectCount_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
params.countBuffer = countBuffer;
|
|
|
|
params.countBufferOffset = countBufferOffset;
|
|
|
|
params.maxDrawCount = maxDrawCount;
|
|
|
|
params.stride = stride;
|
|
|
|
unix_funcs->p_vkCmdDrawIndirectCount(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawIndirectCountAMD_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
params.countBuffer = countBuffer;
|
|
|
|
params.countBufferOffset = countBufferOffset;
|
|
|
|
params.maxDrawCount = maxDrawCount;
|
|
|
|
params.stride = stride;
|
|
|
|
unix_funcs->p_vkCmdDrawIndirectCountAMD(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawIndirectCountKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
params.countBuffer = countBuffer;
|
|
|
|
params.countBufferOffset = countBufferOffset;
|
|
|
|
params.maxDrawCount = maxDrawCount;
|
|
|
|
params.stride = stride;
|
|
|
|
unix_funcs->p_vkCmdDrawIndirectCountKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawMeshTasksIndirectCountNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
params.countBuffer = countBuffer;
|
|
|
|
params.countBufferOffset = countBufferOffset;
|
|
|
|
params.maxDrawCount = maxDrawCount;
|
|
|
|
params.stride = stride;
|
|
|
|
unix_funcs->p_vkCmdDrawMeshTasksIndirectCountNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawMeshTasksIndirectNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.offset = offset;
|
|
|
|
params.drawCount = drawCount;
|
|
|
|
params.stride = stride;
|
|
|
|
unix_funcs->p_vkCmdDrawMeshTasksIndirectNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawMeshTasksNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.taskCount = taskCount;
|
|
|
|
params.firstTask = firstTask;
|
|
|
|
unix_funcs->p_vkCmdDrawMeshTasksNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-06-21 11:03:22 +02:00
|
|
|
void WINAPI vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawMultiEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.drawCount = drawCount;
|
|
|
|
params.pVertexInfo = pVertexInfo;
|
|
|
|
params.instanceCount = instanceCount;
|
|
|
|
params.firstInstance = firstInstance;
|
|
|
|
params.stride = stride;
|
|
|
|
unix_funcs->p_vkCmdDrawMultiEXT(¶ms);
|
2021-06-21 11:03:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void WINAPI vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdDrawMultiIndexedEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.drawCount = drawCount;
|
|
|
|
params.pIndexInfo = pIndexInfo;
|
|
|
|
params.instanceCount = instanceCount;
|
|
|
|
params.firstInstance = firstInstance;
|
|
|
|
params.stride = stride;
|
|
|
|
params.pVertexOffset = pVertexOffset;
|
|
|
|
unix_funcs->p_vkCmdDrawMultiIndexedEXT(¶ms);
|
2021-06-21 11:03:22 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdEndConditionalRenderingEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
unix_funcs->p_vkCmdEndConditionalRenderingEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdEndDebugUtilsLabelEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
unix_funcs->p_vkCmdEndDebugUtilsLabelEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdEndQuery_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.query = query;
|
|
|
|
unix_funcs->p_vkCmdEndQuery(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdEndQueryIndexedEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.query = query;
|
|
|
|
params.index = index;
|
|
|
|
unix_funcs->p_vkCmdEndQueryIndexedEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdEndRenderPass_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
unix_funcs->p_vkCmdEndRenderPass(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdEndRenderPass2_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pSubpassEndInfo = pSubpassEndInfo;
|
|
|
|
unix_funcs->p_vkCmdEndRenderPass2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdEndRenderPass2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pSubpassEndInfo = pSubpassEndInfo;
|
|
|
|
unix_funcs->p_vkCmdEndRenderPass2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-11-02 11:59:57 +01:00
|
|
|
void WINAPI vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdEndRenderingKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
unix_funcs->p_vkCmdEndRenderingKHR(¶ms);
|
2021-11-02 11:59:57 +01:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdEndTransformFeedbackEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.firstCounterBuffer = firstCounterBuffer;
|
|
|
|
params.counterBufferCount = counterBufferCount;
|
|
|
|
params.pCounterBuffers = pCounterBuffers;
|
|
|
|
params.pCounterBufferOffsets = pCounterBufferOffsets;
|
|
|
|
unix_funcs->p_vkCmdEndTransformFeedbackEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdExecuteCommands_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.commandBufferCount = commandBufferCount;
|
|
|
|
params.pCommandBuffers = pCommandBuffers;
|
|
|
|
unix_funcs->p_vkCmdExecuteCommands(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdExecuteGeneratedCommandsNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.isPreprocessed = isPreprocessed;
|
|
|
|
params.pGeneratedCommandsInfo = pGeneratedCommandsInfo;
|
|
|
|
unix_funcs->p_vkCmdExecuteGeneratedCommandsNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdFillBuffer_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.dstBuffer = dstBuffer;
|
|
|
|
params.dstOffset = dstOffset;
|
|
|
|
params.size = size;
|
|
|
|
params.data = data;
|
|
|
|
unix_funcs->p_vkCmdFillBuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdInsertDebugUtilsLabelEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pLabelInfo = pLabelInfo;
|
|
|
|
unix_funcs->p_vkCmdInsertDebugUtilsLabelEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdNextSubpass_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.contents = contents;
|
|
|
|
unix_funcs->p_vkCmdNextSubpass(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdNextSubpass2_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pSubpassBeginInfo = pSubpassBeginInfo;
|
|
|
|
params.pSubpassEndInfo = pSubpassEndInfo;
|
|
|
|
unix_funcs->p_vkCmdNextSubpass2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdNextSubpass2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pSubpassBeginInfo = pSubpassBeginInfo;
|
|
|
|
params.pSubpassEndInfo = pSubpassEndInfo;
|
|
|
|
unix_funcs->p_vkCmdNextSubpass2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI 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)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdPipelineBarrier_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.srcStageMask = srcStageMask;
|
|
|
|
params.dstStageMask = dstStageMask;
|
|
|
|
params.dependencyFlags = dependencyFlags;
|
|
|
|
params.memoryBarrierCount = memoryBarrierCount;
|
|
|
|
params.pMemoryBarriers = pMemoryBarriers;
|
|
|
|
params.bufferMemoryBarrierCount = bufferMemoryBarrierCount;
|
|
|
|
params.pBufferMemoryBarriers = pBufferMemoryBarriers;
|
|
|
|
params.imageMemoryBarrierCount = imageMemoryBarrierCount;
|
|
|
|
params.pImageMemoryBarriers = pImageMemoryBarriers;
|
|
|
|
unix_funcs->p_vkCmdPipelineBarrier(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR *pDependencyInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdPipelineBarrier2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pDependencyInfo = pDependencyInfo;
|
|
|
|
unix_funcs->p_vkCmdPipelineBarrier2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdPreprocessGeneratedCommandsNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pGeneratedCommandsInfo = pGeneratedCommandsInfo;
|
|
|
|
unix_funcs->p_vkCmdPreprocessGeneratedCommandsNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdPushConstants_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.layout = layout;
|
|
|
|
params.stageFlags = stageFlags;
|
|
|
|
params.offset = offset;
|
|
|
|
params.size = size;
|
|
|
|
params.pValues = pValues;
|
|
|
|
unix_funcs->p_vkCmdPushConstants(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdPushDescriptorSetKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pipelineBindPoint = pipelineBindPoint;
|
|
|
|
params.layout = layout;
|
|
|
|
params.set = set;
|
|
|
|
params.descriptorWriteCount = descriptorWriteCount;
|
|
|
|
params.pDescriptorWrites = pDescriptorWrites;
|
|
|
|
unix_funcs->p_vkCmdPushDescriptorSetKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdPushDescriptorSetWithTemplateKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.descriptorUpdateTemplate = descriptorUpdateTemplate;
|
|
|
|
params.layout = layout;
|
|
|
|
params.set = set;
|
|
|
|
params.pData = pData;
|
|
|
|
unix_funcs->p_vkCmdPushDescriptorSetWithTemplateKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdResetEvent_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.event = event;
|
|
|
|
params.stageMask = stageMask;
|
|
|
|
unix_funcs->p_vkCmdResetEvent(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdResetEvent2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.event = event;
|
|
|
|
params.stageMask = stageMask;
|
|
|
|
unix_funcs->p_vkCmdResetEvent2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdResetQueryPool_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.firstQuery = firstQuery;
|
|
|
|
params.queryCount = queryCount;
|
|
|
|
unix_funcs->p_vkCmdResetQueryPool(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdResolveImage_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.srcImage = srcImage;
|
|
|
|
params.srcImageLayout = srcImageLayout;
|
|
|
|
params.dstImage = dstImage;
|
|
|
|
params.dstImageLayout = dstImageLayout;
|
|
|
|
params.regionCount = regionCount;
|
|
|
|
params.pRegions = pRegions;
|
|
|
|
unix_funcs->p_vkCmdResolveImage(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdResolveImage2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pResolveImageInfo = pResolveImageInfo;
|
|
|
|
unix_funcs->p_vkCmdResolveImage2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetBlendConstants_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.blendConstants = blendConstants;
|
|
|
|
unix_funcs->p_vkCmdSetBlendConstants(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetCheckpointNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pCheckpointMarker = pCheckpointMarker;
|
|
|
|
unix_funcs->p_vkCmdSetCheckpointNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetCoarseSampleOrderNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.sampleOrderType = sampleOrderType;
|
|
|
|
params.customSampleOrderCount = customSampleOrderCount;
|
|
|
|
params.pCustomSampleOrders = pCustomSampleOrders;
|
|
|
|
unix_funcs->p_vkCmdSetCoarseSampleOrderNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
|
2021-04-19 21:45:39 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetColorWriteEnableEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.attachmentCount = attachmentCount;
|
|
|
|
params.pColorWriteEnables = pColorWriteEnables;
|
|
|
|
unix_funcs->p_vkCmdSetColorWriteEnableEXT(¶ms);
|
2021-04-19 21:45:39 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetCullModeEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.cullMode = cullMode;
|
|
|
|
unix_funcs->p_vkCmdSetCullModeEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetDepthBias_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.depthBiasConstantFactor = depthBiasConstantFactor;
|
|
|
|
params.depthBiasClamp = depthBiasClamp;
|
|
|
|
params.depthBiasSlopeFactor = depthBiasSlopeFactor;
|
|
|
|
unix_funcs->p_vkCmdSetDepthBias(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
|
2021-04-19 21:45:39 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetDepthBiasEnableEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.depthBiasEnable = depthBiasEnable;
|
|
|
|
unix_funcs->p_vkCmdSetDepthBiasEnableEXT(¶ms);
|
2021-04-19 21:45:39 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetDepthBounds_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.minDepthBounds = minDepthBounds;
|
|
|
|
params.maxDepthBounds = maxDepthBounds;
|
|
|
|
unix_funcs->p_vkCmdSetDepthBounds(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetDepthBoundsTestEnableEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.depthBoundsTestEnable = depthBoundsTestEnable;
|
|
|
|
unix_funcs->p_vkCmdSetDepthBoundsTestEnableEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetDepthCompareOpEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.depthCompareOp = depthCompareOp;
|
|
|
|
unix_funcs->p_vkCmdSetDepthCompareOpEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetDepthTestEnableEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.depthTestEnable = depthTestEnable;
|
|
|
|
unix_funcs->p_vkCmdSetDepthTestEnableEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetDepthWriteEnableEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.depthWriteEnable = depthWriteEnable;
|
|
|
|
unix_funcs->p_vkCmdSetDepthWriteEnableEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetDeviceMask_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.deviceMask = deviceMask;
|
|
|
|
unix_funcs->p_vkCmdSetDeviceMask(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetDeviceMaskKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.deviceMask = deviceMask;
|
|
|
|
unix_funcs->p_vkCmdSetDeviceMaskKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetDiscardRectangleEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.firstDiscardRectangle = firstDiscardRectangle;
|
|
|
|
params.discardRectangleCount = discardRectangleCount;
|
|
|
|
params.pDiscardRectangles = pDiscardRectangles;
|
|
|
|
unix_funcs->p_vkCmdSetDiscardRectangleEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetEvent_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.event = event;
|
|
|
|
params.stageMask = stageMask;
|
|
|
|
unix_funcs->p_vkCmdSetEvent(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR *pDependencyInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetEvent2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.event = event;
|
|
|
|
params.pDependencyInfo = pDependencyInfo;
|
|
|
|
unix_funcs->p_vkCmdSetEvent2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetExclusiveScissorNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.firstExclusiveScissor = firstExclusiveScissor;
|
|
|
|
params.exclusiveScissorCount = exclusiveScissorCount;
|
|
|
|
params.pExclusiveScissors = pExclusiveScissors;
|
|
|
|
unix_funcs->p_vkCmdSetExclusiveScissorNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetFragmentShadingRateEnumNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.shadingRate = shadingRate;
|
|
|
|
params.combinerOps = combinerOps;
|
|
|
|
unix_funcs->p_vkCmdSetFragmentShadingRateEnumNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetFragmentShadingRateKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pFragmentSize = pFragmentSize;
|
|
|
|
params.combinerOps = combinerOps;
|
|
|
|
unix_funcs->p_vkCmdSetFragmentShadingRateKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetFrontFaceEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.frontFace = frontFace;
|
|
|
|
unix_funcs->p_vkCmdSetFrontFaceEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetLineStippleEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.lineStippleFactor = lineStippleFactor;
|
|
|
|
params.lineStipplePattern = lineStipplePattern;
|
|
|
|
unix_funcs->p_vkCmdSetLineStippleEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetLineWidth_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.lineWidth = lineWidth;
|
|
|
|
unix_funcs->p_vkCmdSetLineWidth(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
|
2021-04-19 21:45:39 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetLogicOpEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.logicOp = logicOp;
|
|
|
|
unix_funcs->p_vkCmdSetLogicOpEXT(¶ms);
|
2021-04-19 21:45:39 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
|
2021-04-19 21:45:39 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetPatchControlPointsEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.patchControlPoints = patchControlPoints;
|
|
|
|
unix_funcs->p_vkCmdSetPatchControlPointsEXT(¶ms);
|
2021-04-19 21:45:39 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetPerformanceMarkerINTEL_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pMarkerInfo = pMarkerInfo;
|
|
|
|
return unix_funcs->p_vkCmdSetPerformanceMarkerINTEL(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetPerformanceOverrideINTEL_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pOverrideInfo = pOverrideInfo;
|
|
|
|
return unix_funcs->p_vkCmdSetPerformanceOverrideINTEL(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetPerformanceStreamMarkerINTEL_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pMarkerInfo = pMarkerInfo;
|
|
|
|
return unix_funcs->p_vkCmdSetPerformanceStreamMarkerINTEL(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
|
2021-04-19 21:45:39 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetPrimitiveRestartEnableEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.primitiveRestartEnable = primitiveRestartEnable;
|
|
|
|
unix_funcs->p_vkCmdSetPrimitiveRestartEnableEXT(¶ms);
|
2021-04-19 21:45:39 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetPrimitiveTopologyEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.primitiveTopology = primitiveTopology;
|
|
|
|
unix_funcs->p_vkCmdSetPrimitiveTopologyEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
|
2021-04-19 21:45:39 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetRasterizerDiscardEnableEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.rasterizerDiscardEnable = rasterizerDiscardEnable;
|
|
|
|
unix_funcs->p_vkCmdSetRasterizerDiscardEnableEXT(¶ms);
|
2021-04-19 21:45:39 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetRayTracingPipelineStackSizeKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pipelineStackSize = pipelineStackSize;
|
|
|
|
unix_funcs->p_vkCmdSetRayTracingPipelineStackSizeKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetSampleLocationsEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pSampleLocationsInfo = pSampleLocationsInfo;
|
|
|
|
unix_funcs->p_vkCmdSetSampleLocationsEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetScissor_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.firstScissor = firstScissor;
|
|
|
|
params.scissorCount = scissorCount;
|
|
|
|
params.pScissors = pScissors;
|
|
|
|
unix_funcs->p_vkCmdSetScissor(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetScissorWithCountEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.scissorCount = scissorCount;
|
|
|
|
params.pScissors = pScissors;
|
|
|
|
unix_funcs->p_vkCmdSetScissorWithCountEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetStencilCompareMask_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.faceMask = faceMask;
|
|
|
|
params.compareMask = compareMask;
|
|
|
|
unix_funcs->p_vkCmdSetStencilCompareMask(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetStencilOpEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.faceMask = faceMask;
|
|
|
|
params.failOp = failOp;
|
|
|
|
params.passOp = passOp;
|
|
|
|
params.depthFailOp = depthFailOp;
|
|
|
|
params.compareOp = compareOp;
|
|
|
|
unix_funcs->p_vkCmdSetStencilOpEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetStencilReference_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.faceMask = faceMask;
|
|
|
|
params.reference = reference;
|
|
|
|
unix_funcs->p_vkCmdSetStencilReference(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetStencilTestEnableEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.stencilTestEnable = stencilTestEnable;
|
|
|
|
unix_funcs->p_vkCmdSetStencilTestEnableEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetStencilWriteMask_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.faceMask = faceMask;
|
|
|
|
params.writeMask = writeMask;
|
|
|
|
unix_funcs->p_vkCmdSetStencilWriteMask(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
|
2021-04-19 21:45:39 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetVertexInputEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.vertexBindingDescriptionCount = vertexBindingDescriptionCount;
|
|
|
|
params.pVertexBindingDescriptions = pVertexBindingDescriptions;
|
|
|
|
params.vertexAttributeDescriptionCount = vertexAttributeDescriptionCount;
|
|
|
|
params.pVertexAttributeDescriptions = pVertexAttributeDescriptions;
|
|
|
|
unix_funcs->p_vkCmdSetVertexInputEXT(¶ms);
|
2021-04-19 21:45:39 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetViewport_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.firstViewport = firstViewport;
|
|
|
|
params.viewportCount = viewportCount;
|
|
|
|
params.pViewports = pViewports;
|
|
|
|
unix_funcs->p_vkCmdSetViewport(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetViewportShadingRatePaletteNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.firstViewport = firstViewport;
|
|
|
|
params.viewportCount = viewportCount;
|
|
|
|
params.pShadingRatePalettes = pShadingRatePalettes;
|
|
|
|
unix_funcs->p_vkCmdSetViewportShadingRatePaletteNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetViewportWScalingNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.firstViewport = firstViewport;
|
|
|
|
params.viewportCount = viewportCount;
|
|
|
|
params.pViewportWScalings = pViewportWScalings;
|
|
|
|
unix_funcs->p_vkCmdSetViewportWScalingNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSetViewportWithCountEXT_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.viewportCount = viewportCount;
|
|
|
|
params.pViewports = pViewports;
|
|
|
|
unix_funcs->p_vkCmdSetViewportWithCountEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-07-20 15:04:49 +02:00
|
|
|
void WINAPI vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdSubpassShadingHUAWEI_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
unix_funcs->p_vkCmdSubpassShadingHUAWEI(¶ms);
|
2021-07-20 15:04:49 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdTraceRaysIndirectKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pRaygenShaderBindingTable = pRaygenShaderBindingTable;
|
|
|
|
params.pMissShaderBindingTable = pMissShaderBindingTable;
|
|
|
|
params.pHitShaderBindingTable = pHitShaderBindingTable;
|
|
|
|
params.pCallableShaderBindingTable = pCallableShaderBindingTable;
|
|
|
|
params.indirectDeviceAddress = indirectDeviceAddress;
|
|
|
|
unix_funcs->p_vkCmdTraceRaysIndirectKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdTraceRaysKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pRaygenShaderBindingTable = pRaygenShaderBindingTable;
|
|
|
|
params.pMissShaderBindingTable = pMissShaderBindingTable;
|
|
|
|
params.pHitShaderBindingTable = pHitShaderBindingTable;
|
|
|
|
params.pCallableShaderBindingTable = pCallableShaderBindingTable;
|
|
|
|
params.width = width;
|
|
|
|
params.height = height;
|
|
|
|
params.depth = depth;
|
|
|
|
unix_funcs->p_vkCmdTraceRaysKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdTraceRaysNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.raygenShaderBindingTableBuffer = raygenShaderBindingTableBuffer;
|
|
|
|
params.raygenShaderBindingOffset = raygenShaderBindingOffset;
|
|
|
|
params.missShaderBindingTableBuffer = missShaderBindingTableBuffer;
|
|
|
|
params.missShaderBindingOffset = missShaderBindingOffset;
|
|
|
|
params.missShaderBindingStride = missShaderBindingStride;
|
|
|
|
params.hitShaderBindingTableBuffer = hitShaderBindingTableBuffer;
|
|
|
|
params.hitShaderBindingOffset = hitShaderBindingOffset;
|
|
|
|
params.hitShaderBindingStride = hitShaderBindingStride;
|
|
|
|
params.callableShaderBindingTableBuffer = callableShaderBindingTableBuffer;
|
|
|
|
params.callableShaderBindingOffset = callableShaderBindingOffset;
|
|
|
|
params.callableShaderBindingStride = callableShaderBindingStride;
|
|
|
|
params.width = width;
|
|
|
|
params.height = height;
|
|
|
|
params.depth = depth;
|
|
|
|
unix_funcs->p_vkCmdTraceRaysNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdUpdateBuffer_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.dstBuffer = dstBuffer;
|
|
|
|
params.dstOffset = dstOffset;
|
|
|
|
params.dataSize = dataSize;
|
|
|
|
params.pData = pData;
|
|
|
|
unix_funcs->p_vkCmdUpdateBuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI 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)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdWaitEvents_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.eventCount = eventCount;
|
|
|
|
params.pEvents = pEvents;
|
|
|
|
params.srcStageMask = srcStageMask;
|
|
|
|
params.dstStageMask = dstStageMask;
|
|
|
|
params.memoryBarrierCount = memoryBarrierCount;
|
|
|
|
params.pMemoryBarriers = pMemoryBarriers;
|
|
|
|
params.bufferMemoryBarrierCount = bufferMemoryBarrierCount;
|
|
|
|
params.pBufferMemoryBarriers = pBufferMemoryBarriers;
|
|
|
|
params.imageMemoryBarrierCount = imageMemoryBarrierCount;
|
|
|
|
params.pImageMemoryBarriers = pImageMemoryBarriers;
|
|
|
|
unix_funcs->p_vkCmdWaitEvents(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfoKHR *pDependencyInfos)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdWaitEvents2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.eventCount = eventCount;
|
|
|
|
params.pEvents = pEvents;
|
|
|
|
params.pDependencyInfos = pDependencyInfos;
|
|
|
|
unix_funcs->p_vkCmdWaitEvents2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdWriteAccelerationStructuresPropertiesKHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.accelerationStructureCount = accelerationStructureCount;
|
|
|
|
params.pAccelerationStructures = pAccelerationStructures;
|
|
|
|
params.queryType = queryType;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.firstQuery = firstQuery;
|
|
|
|
unix_funcs->p_vkCmdWriteAccelerationStructuresPropertiesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdWriteAccelerationStructuresPropertiesNV_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.accelerationStructureCount = accelerationStructureCount;
|
|
|
|
params.pAccelerationStructures = pAccelerationStructures;
|
|
|
|
params.queryType = queryType;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.firstQuery = firstQuery;
|
|
|
|
unix_funcs->p_vkCmdWriteAccelerationStructuresPropertiesNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdWriteBufferMarker2AMD_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.stage = stage;
|
|
|
|
params.dstBuffer = dstBuffer;
|
|
|
|
params.dstOffset = dstOffset;
|
|
|
|
params.marker = marker;
|
|
|
|
unix_funcs->p_vkCmdWriteBufferMarker2AMD(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdWriteBufferMarkerAMD_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pipelineStage = pipelineStage;
|
|
|
|
params.dstBuffer = dstBuffer;
|
|
|
|
params.dstOffset = dstOffset;
|
|
|
|
params.marker = marker;
|
|
|
|
unix_funcs->p_vkCmdWriteBufferMarkerAMD(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdWriteTimestamp_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.pipelineStage = pipelineStage;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.query = query;
|
|
|
|
unix_funcs->p_vkCmdWriteTimestamp(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCmdWriteTimestamp2KHR_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.stage = stage;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.query = query;
|
|
|
|
unix_funcs->p_vkCmdWriteTimestamp2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCompileDeferredNV_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipeline = pipeline;
|
|
|
|
params.shader = shader;
|
|
|
|
return unix_funcs->p_vkCompileDeferredNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCopyAccelerationStructureKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.deferredOperation = deferredOperation;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
return unix_funcs->p_vkCopyAccelerationStructureKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCopyAccelerationStructureToMemoryKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.deferredOperation = deferredOperation;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
return unix_funcs->p_vkCopyAccelerationStructureToMemoryKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCopyMemoryToAccelerationStructureKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.deferredOperation = deferredOperation;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
return unix_funcs->p_vkCopyMemoryToAccelerationStructureKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateAccelerationStructureKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pAccelerationStructure = pAccelerationStructure;
|
|
|
|
return unix_funcs->p_vkCreateAccelerationStructureKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateAccelerationStructureNV_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pAccelerationStructure = pAccelerationStructure;
|
|
|
|
return unix_funcs->p_vkCreateAccelerationStructureNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateBuffer_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pBuffer = pBuffer;
|
|
|
|
return unix_funcs->p_vkCreateBuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateBufferView_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pView = pView;
|
|
|
|
return unix_funcs->p_vkCreateBufferView(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateCommandPool_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pCommandPool = pCommandPool;
|
|
|
|
return unix_funcs->p_vkCreateCommandPool(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateComputePipelines_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipelineCache = pipelineCache;
|
|
|
|
params.createInfoCount = createInfoCount;
|
|
|
|
params.pCreateInfos = pCreateInfos;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pPipelines = pPipelines;
|
|
|
|
return unix_funcs->p_vkCreateComputePipelines(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-05-10 12:29:08 +02:00
|
|
|
VkResult WINAPI vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateCuFunctionNVX_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pFunction = pFunction;
|
|
|
|
return unix_funcs->p_vkCreateCuFunctionNVX(¶ms);
|
2021-05-10 12:29:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
VkResult WINAPI vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateCuModuleNVX_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pModule = pModule;
|
|
|
|
return unix_funcs->p_vkCreateCuModuleNVX(¶ms);
|
2021-05-10 12:29:08 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateDebugReportCallbackEXT_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pCallback = pCallback;
|
|
|
|
return unix_funcs->p_vkCreateDebugReportCallbackEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateDebugUtilsMessengerEXT_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pMessenger = pMessenger;
|
|
|
|
return unix_funcs->p_vkCreateDebugUtilsMessengerEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateDeferredOperationKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pDeferredOperation = pDeferredOperation;
|
|
|
|
return unix_funcs->p_vkCreateDeferredOperationKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateDescriptorPool_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pDescriptorPool = pDescriptorPool;
|
|
|
|
return unix_funcs->p_vkCreateDescriptorPool(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateDescriptorSetLayout_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pSetLayout = pSetLayout;
|
|
|
|
return unix_funcs->p_vkCreateDescriptorSetLayout(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateDescriptorUpdateTemplate_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pDescriptorUpdateTemplate = pDescriptorUpdateTemplate;
|
|
|
|
return unix_funcs->p_vkCreateDescriptorUpdateTemplate(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateDescriptorUpdateTemplateKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pDescriptorUpdateTemplate = pDescriptorUpdateTemplate;
|
|
|
|
return unix_funcs->p_vkCreateDescriptorUpdateTemplateKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateDevice_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pDevice = pDevice;
|
|
|
|
return unix_funcs->p_vkCreateDevice(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateEvent_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pEvent = pEvent;
|
|
|
|
return unix_funcs->p_vkCreateEvent(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateFence_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pFence = pFence;
|
|
|
|
return unix_funcs->p_vkCreateFence(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateFramebuffer_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pFramebuffer = pFramebuffer;
|
|
|
|
return unix_funcs->p_vkCreateFramebuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateGraphicsPipelines_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipelineCache = pipelineCache;
|
|
|
|
params.createInfoCount = createInfoCount;
|
|
|
|
params.pCreateInfos = pCreateInfos;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pPipelines = pPipelines;
|
|
|
|
return unix_funcs->p_vkCreateGraphicsPipelines(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateImage_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pImage = pImage;
|
|
|
|
return unix_funcs->p_vkCreateImage(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateImageView_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pView = pView;
|
|
|
|
return unix_funcs->p_vkCreateImageView(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateIndirectCommandsLayoutNV_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pIndirectCommandsLayout = pIndirectCommandsLayout;
|
|
|
|
return unix_funcs->p_vkCreateIndirectCommandsLayoutNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreatePipelineCache_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pPipelineCache = pPipelineCache;
|
|
|
|
return unix_funcs->p_vkCreatePipelineCache(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreatePipelineLayout_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pPipelineLayout = pPipelineLayout;
|
|
|
|
return unix_funcs->p_vkCreatePipelineLayout(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlotEXT *pPrivateDataSlot)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreatePrivateDataSlotEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pPrivateDataSlot = pPrivateDataSlot;
|
|
|
|
return unix_funcs->p_vkCreatePrivateDataSlotEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateQueryPool_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pQueryPool = pQueryPool;
|
|
|
|
return unix_funcs->p_vkCreateQueryPool(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateRayTracingPipelinesKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.deferredOperation = deferredOperation;
|
|
|
|
params.pipelineCache = pipelineCache;
|
|
|
|
params.createInfoCount = createInfoCount;
|
|
|
|
params.pCreateInfos = pCreateInfos;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pPipelines = pPipelines;
|
|
|
|
return unix_funcs->p_vkCreateRayTracingPipelinesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateRayTracingPipelinesNV_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipelineCache = pipelineCache;
|
|
|
|
params.createInfoCount = createInfoCount;
|
|
|
|
params.pCreateInfos = pCreateInfos;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pPipelines = pPipelines;
|
|
|
|
return unix_funcs->p_vkCreateRayTracingPipelinesNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateRenderPass_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pRenderPass = pRenderPass;
|
|
|
|
return unix_funcs->p_vkCreateRenderPass(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateRenderPass2_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pRenderPass = pRenderPass;
|
|
|
|
return unix_funcs->p_vkCreateRenderPass2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateRenderPass2KHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pRenderPass = pRenderPass;
|
|
|
|
return unix_funcs->p_vkCreateRenderPass2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateSampler_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pSampler = pSampler;
|
|
|
|
return unix_funcs->p_vkCreateSampler(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateSamplerYcbcrConversion_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pYcbcrConversion = pYcbcrConversion;
|
|
|
|
return unix_funcs->p_vkCreateSamplerYcbcrConversion(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateSamplerYcbcrConversionKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pYcbcrConversion = pYcbcrConversion;
|
|
|
|
return unix_funcs->p_vkCreateSamplerYcbcrConversionKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateSemaphore_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pSemaphore = pSemaphore;
|
|
|
|
return unix_funcs->p_vkCreateSemaphore(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateShaderModule_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pShaderModule = pShaderModule;
|
|
|
|
return unix_funcs->p_vkCreateShaderModule(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateSwapchainKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pSwapchain = pSwapchain;
|
|
|
|
return unix_funcs->p_vkCreateSwapchainKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateValidationCacheEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pValidationCache = pValidationCache;
|
|
|
|
return unix_funcs->p_vkCreateValidationCacheEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkCreateWin32SurfaceKHR_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
params.pSurface = pSurface;
|
|
|
|
return unix_funcs->p_vkCreateWin32SurfaceKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDebugMarkerSetObjectNameEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pNameInfo = pNameInfo;
|
|
|
|
return unix_funcs->p_vkDebugMarkerSetObjectNameEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDebugMarkerSetObjectTagEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pTagInfo = pTagInfo;
|
|
|
|
return unix_funcs->p_vkDebugMarkerSetObjectTagEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDebugReportMessageEXT_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.flags = flags;
|
|
|
|
params.objectType = objectType;
|
|
|
|
params.object = object;
|
|
|
|
params.location = location;
|
|
|
|
params.messageCode = messageCode;
|
|
|
|
params.pLayerPrefix = pLayerPrefix;
|
|
|
|
params.pMessage = pMessage;
|
|
|
|
unix_funcs->p_vkDebugReportMessageEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDeferredOperationJoinKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.operation = operation;
|
|
|
|
return unix_funcs->p_vkDeferredOperationJoinKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyAccelerationStructureKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.accelerationStructure = accelerationStructure;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyAccelerationStructureKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyAccelerationStructureNV_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.accelerationStructure = accelerationStructure;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyAccelerationStructureNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyBuffer_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyBuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyBufferView_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.bufferView = bufferView;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyBufferView(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyCommandPool_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.commandPool = commandPool;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyCommandPool(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-05-10 12:29:08 +02:00
|
|
|
void WINAPI vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyCuFunctionNVX_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.function = function;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyCuFunctionNVX(¶ms);
|
2021-05-10 12:29:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void WINAPI vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyCuModuleNVX_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.module = module;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyCuModuleNVX(¶ms);
|
2021-05-10 12:29:08 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyDebugReportCallbackEXT_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.callback = callback;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyDebugReportCallbackEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyDebugUtilsMessengerEXT_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.messenger = messenger;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyDebugUtilsMessengerEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyDeferredOperationKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.operation = operation;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyDeferredOperationKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyDescriptorPool_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.descriptorPool = descriptorPool;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyDescriptorPool(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyDescriptorSetLayout_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.descriptorSetLayout = descriptorSetLayout;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyDescriptorSetLayout(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyDescriptorUpdateTemplate_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.descriptorUpdateTemplate = descriptorUpdateTemplate;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyDescriptorUpdateTemplate(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyDescriptorUpdateTemplateKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.descriptorUpdateTemplate = descriptorUpdateTemplate;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyDescriptorUpdateTemplateKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyDevice_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyDevice(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyEvent_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.event = event;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyEvent(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyFence_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.fence = fence;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyFence(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyFramebuffer_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.framebuffer = framebuffer;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyFramebuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyImage_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.image = image;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyImage(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyImageView_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.imageView = imageView;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyImageView(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyIndirectCommandsLayoutNV_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.indirectCommandsLayout = indirectCommandsLayout;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyIndirectCommandsLayoutNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyInstance_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyInstance(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyPipeline_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipeline = pipeline;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyPipeline(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyPipelineCache_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipelineCache = pipelineCache;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyPipelineCache(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyPipelineLayout_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipelineLayout = pipelineLayout;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyPipelineLayout(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyPrivateDataSlotEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.privateDataSlot = privateDataSlot;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyPrivateDataSlotEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyQueryPool_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyQueryPool(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyRenderPass_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.renderPass = renderPass;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyRenderPass(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroySampler_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.sampler = sampler;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroySampler(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroySamplerYcbcrConversion_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.ycbcrConversion = ycbcrConversion;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroySamplerYcbcrConversion(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroySamplerYcbcrConversionKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.ycbcrConversion = ycbcrConversion;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroySamplerYcbcrConversionKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroySemaphore_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.semaphore = semaphore;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroySemaphore(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyShaderModule_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.shaderModule = shaderModule;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyShaderModule(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroySurfaceKHR_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.surface = surface;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroySurfaceKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroySwapchainKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.swapchain = swapchain;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroySwapchainKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDestroyValidationCacheEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.validationCache = validationCache;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkDestroyValidationCacheEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkDeviceWaitIdle(VkDevice device)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkDeviceWaitIdle_params params;
|
|
|
|
params.device = device;
|
|
|
|
return unix_funcs->p_vkDeviceWaitIdle(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkEndCommandBuffer(VkCommandBuffer commandBuffer)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkEndCommandBuffer_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
return unix_funcs->p_vkEndCommandBuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkEnumerateDeviceExtensionProperties_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pLayerName = pLayerName;
|
|
|
|
params.pPropertyCount = pPropertyCount;
|
|
|
|
params.pProperties = pProperties;
|
|
|
|
return unix_funcs->p_vkEnumerateDeviceExtensionProperties(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkEnumerateDeviceLayerProperties_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pPropertyCount = pPropertyCount;
|
|
|
|
params.pProperties = pProperties;
|
|
|
|
return unix_funcs->p_vkEnumerateDeviceLayerProperties(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkEnumeratePhysicalDeviceGroups_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount;
|
|
|
|
params.pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties;
|
|
|
|
return unix_funcs->p_vkEnumeratePhysicalDeviceGroups(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkEnumeratePhysicalDeviceGroupsKHR_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount;
|
|
|
|
params.pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties;
|
|
|
|
return unix_funcs->p_vkEnumeratePhysicalDeviceGroupsKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.queueFamilyIndex = queueFamilyIndex;
|
|
|
|
params.pCounterCount = pCounterCount;
|
|
|
|
params.pCounters = pCounters;
|
|
|
|
params.pCounterDescriptions = pCounterDescriptions;
|
|
|
|
return unix_funcs->p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkEnumeratePhysicalDevices_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.pPhysicalDeviceCount = pPhysicalDeviceCount;
|
|
|
|
params.pPhysicalDevices = pPhysicalDevices;
|
|
|
|
return unix_funcs->p_vkEnumeratePhysicalDevices(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkFlushMappedMemoryRanges_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.memoryRangeCount = memoryRangeCount;
|
|
|
|
params.pMemoryRanges = pMemoryRanges;
|
|
|
|
return unix_funcs->p_vkFlushMappedMemoryRanges(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkFreeCommandBuffers_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.commandPool = commandPool;
|
|
|
|
params.commandBufferCount = commandBufferCount;
|
|
|
|
params.pCommandBuffers = pCommandBuffers;
|
|
|
|
unix_funcs->p_vkFreeCommandBuffers(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkFreeDescriptorSets_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.descriptorPool = descriptorPool;
|
|
|
|
params.descriptorSetCount = descriptorSetCount;
|
|
|
|
params.pDescriptorSets = pDescriptorSets;
|
|
|
|
return unix_funcs->p_vkFreeDescriptorSets(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkFreeMemory_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.memory = memory;
|
|
|
|
params.pAllocator = pAllocator;
|
|
|
|
unix_funcs->p_vkFreeMemory(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetAccelerationStructureBuildSizesKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.buildType = buildType;
|
|
|
|
params.pBuildInfo = pBuildInfo;
|
|
|
|
params.pMaxPrimitiveCounts = pMaxPrimitiveCounts;
|
|
|
|
params.pSizeInfo = pSizeInfo;
|
|
|
|
unix_funcs->p_vkGetAccelerationStructureBuildSizesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkDeviceAddress WINAPI vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetAccelerationStructureDeviceAddressKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
unix_funcs->p_vkGetAccelerationStructureDeviceAddressKHR(¶ms);
|
|
|
|
return params.result;
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetAccelerationStructureHandleNV_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.accelerationStructure = accelerationStructure;
|
|
|
|
params.dataSize = dataSize;
|
|
|
|
params.pData = pData;
|
|
|
|
return unix_funcs->p_vkGetAccelerationStructureHandleNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetAccelerationStructureMemoryRequirementsNV_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.pMemoryRequirements = pMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetAccelerationStructureMemoryRequirementsNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkDeviceAddress WINAPI vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetBufferDeviceAddress_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
unix_funcs->p_vkGetBufferDeviceAddress(¶ms);
|
|
|
|
return params.result;
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkDeviceAddress WINAPI vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetBufferDeviceAddressEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
unix_funcs->p_vkGetBufferDeviceAddressEXT(¶ms);
|
|
|
|
return params.result;
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkDeviceAddress WINAPI vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetBufferDeviceAddressKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
unix_funcs->p_vkGetBufferDeviceAddressKHR(¶ms);
|
|
|
|
return params.result;
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetBufferMemoryRequirements_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.buffer = buffer;
|
|
|
|
params.pMemoryRequirements = pMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetBufferMemoryRequirements(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetBufferMemoryRequirements2_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.pMemoryRequirements = pMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetBufferMemoryRequirements2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetBufferMemoryRequirements2KHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.pMemoryRequirements = pMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetBufferMemoryRequirements2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
uint64_t WINAPI vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetBufferOpaqueCaptureAddress_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
unix_funcs->p_vkGetBufferOpaqueCaptureAddress(¶ms);
|
|
|
|
return params.result;
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
uint64_t WINAPI vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetBufferOpaqueCaptureAddressKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
unix_funcs->p_vkGetBufferOpaqueCaptureAddressKHR(¶ms);
|
|
|
|
return params.result;
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetCalibratedTimestampsEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.timestampCount = timestampCount;
|
|
|
|
params.pTimestampInfos = pTimestampInfos;
|
|
|
|
params.pTimestamps = pTimestamps;
|
|
|
|
params.pMaxDeviation = pMaxDeviation;
|
|
|
|
return unix_funcs->p_vkGetCalibratedTimestampsEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
uint32_t WINAPI vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeferredOperationMaxConcurrencyKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.operation = operation;
|
|
|
|
return unix_funcs->p_vkGetDeferredOperationMaxConcurrencyKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeferredOperationResultKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.operation = operation;
|
|
|
|
return unix_funcs->p_vkGetDeferredOperationResultKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDescriptorSetLayoutSupport_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pSupport = pSupport;
|
|
|
|
unix_funcs->p_vkGetDescriptorSetLayoutSupport(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDescriptorSetLayoutSupportKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pCreateInfo = pCreateInfo;
|
|
|
|
params.pSupport = pSupport;
|
|
|
|
unix_funcs->p_vkGetDescriptorSetLayoutSupportKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceAccelerationStructureCompatibilityKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pVersionInfo = pVersionInfo;
|
|
|
|
params.pCompatibility = pCompatibility;
|
|
|
|
unix_funcs->p_vkGetDeviceAccelerationStructureCompatibilityKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-10-05 15:40:37 +02:00
|
|
|
void WINAPI vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirementsKHR *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceBufferMemoryRequirementsKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.pMemoryRequirements = pMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetDeviceBufferMemoryRequirementsKHR(¶ms);
|
2021-10-05 15:40:37 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceGroupPeerMemoryFeatures_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.heapIndex = heapIndex;
|
|
|
|
params.localDeviceIndex = localDeviceIndex;
|
|
|
|
params.remoteDeviceIndex = remoteDeviceIndex;
|
|
|
|
params.pPeerMemoryFeatures = pPeerMemoryFeatures;
|
|
|
|
unix_funcs->p_vkGetDeviceGroupPeerMemoryFeatures(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceGroupPeerMemoryFeaturesKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.heapIndex = heapIndex;
|
|
|
|
params.localDeviceIndex = localDeviceIndex;
|
|
|
|
params.remoteDeviceIndex = remoteDeviceIndex;
|
|
|
|
params.pPeerMemoryFeatures = pPeerMemoryFeatures;
|
|
|
|
unix_funcs->p_vkGetDeviceGroupPeerMemoryFeaturesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceGroupPresentCapabilitiesKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pDeviceGroupPresentCapabilities = pDeviceGroupPresentCapabilities;
|
|
|
|
return unix_funcs->p_vkGetDeviceGroupPresentCapabilitiesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceGroupSurfacePresentModesKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.surface = surface;
|
|
|
|
params.pModes = pModes;
|
|
|
|
return unix_funcs->p_vkGetDeviceGroupSurfacePresentModesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-10-05 15:40:37 +02:00
|
|
|
void WINAPI vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirementsKHR *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceImageMemoryRequirementsKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.pMemoryRequirements = pMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetDeviceImageMemoryRequirementsKHR(¶ms);
|
2021-10-05 15:40:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void WINAPI vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirementsKHR *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceImageSparseMemoryRequirementsKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
|
|
|
|
params.pSparseMemoryRequirements = pSparseMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetDeviceImageSparseMemoryRequirementsKHR(¶ms);
|
2021-10-05 15:40:37 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceMemoryCommitment_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.memory = memory;
|
|
|
|
params.pCommittedMemoryInBytes = pCommittedMemoryInBytes;
|
|
|
|
unix_funcs->p_vkGetDeviceMemoryCommitment(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
uint64_t WINAPI vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceMemoryOpaqueCaptureAddress_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
unix_funcs->p_vkGetDeviceMemoryOpaqueCaptureAddress(¶ms);
|
|
|
|
return params.result;
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
uint64_t WINAPI vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceMemoryOpaqueCaptureAddressKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
unix_funcs->p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(¶ms);
|
|
|
|
return params.result;
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceQueue_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.queueFamilyIndex = queueFamilyIndex;
|
|
|
|
params.queueIndex = queueIndex;
|
|
|
|
params.pQueue = pQueue;
|
|
|
|
unix_funcs->p_vkGetDeviceQueue(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceQueue2_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pQueueInfo = pQueueInfo;
|
|
|
|
params.pQueue = pQueue;
|
|
|
|
unix_funcs->p_vkGetDeviceQueue2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-07-20 15:04:49 +02:00
|
|
|
VkResult WINAPI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.renderpass = renderpass;
|
|
|
|
params.pMaxWorkgroupSize = pMaxWorkgroupSize;
|
|
|
|
return unix_funcs->p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(¶ms);
|
2021-07-20 15:04:49 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetEventStatus(VkDevice device, VkEvent event)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetEventStatus_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.event = event;
|
|
|
|
return unix_funcs->p_vkGetEventStatus(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetFenceStatus(VkDevice device, VkFence fence)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetFenceStatus_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.fence = fence;
|
|
|
|
return unix_funcs->p_vkGetFenceStatus(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetGeneratedCommandsMemoryRequirementsNV_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.pMemoryRequirements = pMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetGeneratedCommandsMemoryRequirementsNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetImageMemoryRequirements_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.image = image;
|
|
|
|
params.pMemoryRequirements = pMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetImageMemoryRequirements(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetImageMemoryRequirements2_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.pMemoryRequirements = pMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetImageMemoryRequirements2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetImageMemoryRequirements2KHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.pMemoryRequirements = pMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetImageMemoryRequirements2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetImageSparseMemoryRequirements_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.image = image;
|
|
|
|
params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
|
|
|
|
params.pSparseMemoryRequirements = pSparseMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetImageSparseMemoryRequirements(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetImageSparseMemoryRequirements2_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
|
|
|
|
params.pSparseMemoryRequirements = pSparseMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetImageSparseMemoryRequirements2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetImageSparseMemoryRequirements2KHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
|
|
|
|
params.pSparseMemoryRequirements = pSparseMemoryRequirements;
|
|
|
|
unix_funcs->p_vkGetImageSparseMemoryRequirements2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetImageSubresourceLayout_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.image = image;
|
|
|
|
params.pSubresource = pSubresource;
|
|
|
|
params.pLayout = pLayout;
|
|
|
|
unix_funcs->p_vkGetImageSubresourceLayout(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-05-10 12:29:07 +02:00
|
|
|
VkResult WINAPI vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetImageViewAddressNVX_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.imageView = imageView;
|
|
|
|
params.pProperties = pProperties;
|
|
|
|
return unix_funcs->p_vkGetImageViewAddressNVX(¶ms);
|
2021-05-10 12:29:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t WINAPI vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetImageViewHandleNVX_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
return unix_funcs->p_vkGetImageViewHandleNVX(¶ms);
|
2021-05-10 12:29:07 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetMemoryHostPointerPropertiesEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.handleType = handleType;
|
|
|
|
params.pHostPointer = pHostPointer;
|
|
|
|
params.pMemoryHostPointerProperties = pMemoryHostPointerProperties;
|
|
|
|
return unix_funcs->p_vkGetMemoryHostPointerPropertiesEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPerformanceParameterINTEL_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.parameter = parameter;
|
|
|
|
params.pValue = pValue;
|
|
|
|
return unix_funcs->p_vkGetPerformanceParameterINTEL(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pTimeDomainCount = pTimeDomainCount;
|
|
|
|
params.pTimeDomains = pTimeDomains;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pPropertyCount = pPropertyCount;
|
|
|
|
params.pProperties = pProperties;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceExternalBufferProperties_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pExternalBufferInfo = pExternalBufferInfo;
|
|
|
|
params.pExternalBufferProperties = pExternalBufferProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceExternalBufferProperties(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pExternalBufferInfo = pExternalBufferInfo;
|
|
|
|
params.pExternalBufferProperties = pExternalBufferProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceExternalBufferPropertiesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceExternalFenceProperties_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pExternalFenceInfo = pExternalFenceInfo;
|
|
|
|
params.pExternalFenceProperties = pExternalFenceProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceExternalFenceProperties(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceExternalFencePropertiesKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pExternalFenceInfo = pExternalFenceInfo;
|
|
|
|
params.pExternalFenceProperties = pExternalFenceProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceExternalFencePropertiesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceExternalSemaphoreProperties_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pExternalSemaphoreInfo = pExternalSemaphoreInfo;
|
|
|
|
params.pExternalSemaphoreProperties = pExternalSemaphoreProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceExternalSemaphoreProperties(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pExternalSemaphoreInfo = pExternalSemaphoreInfo;
|
|
|
|
params.pExternalSemaphoreProperties = pExternalSemaphoreProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceFeatures_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pFeatures = pFeatures;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceFeatures(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceFeatures2_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pFeatures = pFeatures;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceFeatures2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceFeatures2KHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pFeatures = pFeatures;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceFeatures2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceFormatProperties_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.format = format;
|
|
|
|
params.pFormatProperties = pFormatProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceFormatProperties(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceFormatProperties2_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.format = format;
|
|
|
|
params.pFormatProperties = pFormatProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceFormatProperties2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceFormatProperties2KHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.format = format;
|
|
|
|
params.pFormatProperties = pFormatProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceFormatProperties2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pFragmentShadingRateCount = pFragmentShadingRateCount;
|
|
|
|
params.pFragmentShadingRates = pFragmentShadingRates;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceFragmentShadingRatesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceImageFormatProperties_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.format = format;
|
|
|
|
params.type = type;
|
|
|
|
params.tiling = tiling;
|
|
|
|
params.usage = usage;
|
|
|
|
params.flags = flags;
|
|
|
|
params.pImageFormatProperties = pImageFormatProperties;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceImageFormatProperties(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceImageFormatProperties2_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pImageFormatInfo = pImageFormatInfo;
|
|
|
|
params.pImageFormatProperties = pImageFormatProperties;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceImageFormatProperties2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceImageFormatProperties2KHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pImageFormatInfo = pImageFormatInfo;
|
|
|
|
params.pImageFormatProperties = pImageFormatProperties;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceImageFormatProperties2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceMemoryProperties_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pMemoryProperties = pMemoryProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceMemoryProperties(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceMemoryProperties2_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pMemoryProperties = pMemoryProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceMemoryProperties2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceMemoryProperties2KHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pMemoryProperties = pMemoryProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceMemoryProperties2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceMultisamplePropertiesEXT_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.samples = samples;
|
|
|
|
params.pMultisampleProperties = pMultisampleProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceMultisamplePropertiesEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDevicePresentRectanglesKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.surface = surface;
|
|
|
|
params.pRectCount = pRectCount;
|
|
|
|
params.pRects = pRects;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDevicePresentRectanglesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceProperties_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pProperties = pProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceProperties(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pPerformanceQueryCreateInfo = pPerformanceQueryCreateInfo;
|
|
|
|
params.pNumPasses = pNumPasses;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceQueueFamilyProperties_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount;
|
|
|
|
params.pQueueFamilyProperties = pQueueFamilyProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceQueueFamilyProperties(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceQueueFamilyProperties2_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount;
|
|
|
|
params.pQueueFamilyProperties = pQueueFamilyProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceQueueFamilyProperties2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceQueueFamilyProperties2KHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount;
|
|
|
|
params.pQueueFamilyProperties = pQueueFamilyProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceSparseImageFormatProperties_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.format = format;
|
|
|
|
params.type = type;
|
|
|
|
params.samples = samples;
|
|
|
|
params.usage = usage;
|
|
|
|
params.tiling = tiling;
|
|
|
|
params.pPropertyCount = pPropertyCount;
|
|
|
|
params.pProperties = pProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceSparseImageFormatProperties(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceSparseImageFormatProperties2_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pFormatInfo = pFormatInfo;
|
|
|
|
params.pPropertyCount = pPropertyCount;
|
|
|
|
params.pProperties = pProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceSparseImageFormatProperties2(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceSparseImageFormatProperties2KHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pFormatInfo = pFormatInfo;
|
|
|
|
params.pPropertyCount = pPropertyCount;
|
|
|
|
params.pProperties = pProperties;
|
|
|
|
unix_funcs->p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pCombinationCount = pCombinationCount;
|
|
|
|
params.pCombinations = pCombinations;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pSurfaceInfo = pSurfaceInfo;
|
|
|
|
params.pSurfaceCapabilities = pSurfaceCapabilities;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceSurfaceCapabilities2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.surface = surface;
|
|
|
|
params.pSurfaceCapabilities = pSurfaceCapabilities;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceSurfaceFormats2KHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pSurfaceInfo = pSurfaceInfo;
|
|
|
|
params.pSurfaceFormatCount = pSurfaceFormatCount;
|
|
|
|
params.pSurfaceFormats = pSurfaceFormats;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceSurfaceFormats2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceSurfaceFormatsKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.surface = surface;
|
|
|
|
params.pSurfaceFormatCount = pSurfaceFormatCount;
|
|
|
|
params.pSurfaceFormats = pSurfaceFormats;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceSurfaceFormatsKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceSurfacePresentModesKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.surface = surface;
|
|
|
|
params.pPresentModeCount = pPresentModeCount;
|
|
|
|
params.pPresentModes = pPresentModes;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceSurfacePresentModesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceSurfaceSupportKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.queueFamilyIndex = queueFamilyIndex;
|
|
|
|
params.surface = surface;
|
|
|
|
params.pSupported = pSupported;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceSurfaceSupportKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolPropertiesEXT *pToolProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceToolPropertiesEXT_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.pToolCount = pToolCount;
|
|
|
|
params.pToolProperties = pToolProperties;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceToolPropertiesEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkBool32 WINAPI vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params params;
|
|
|
|
params.physicalDevice = physicalDevice;
|
|
|
|
params.queueFamilyIndex = queueFamilyIndex;
|
|
|
|
return unix_funcs->p_vkGetPhysicalDeviceWin32PresentationSupportKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPipelineCacheData_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipelineCache = pipelineCache;
|
|
|
|
params.pDataSize = pDataSize;
|
|
|
|
params.pData = pData;
|
|
|
|
return unix_funcs->p_vkGetPipelineCacheData(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPipelineExecutableInternalRepresentationsKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pExecutableInfo = pExecutableInfo;
|
|
|
|
params.pInternalRepresentationCount = pInternalRepresentationCount;
|
|
|
|
params.pInternalRepresentations = pInternalRepresentations;
|
|
|
|
return unix_funcs->p_vkGetPipelineExecutableInternalRepresentationsKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPipelineExecutablePropertiesKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pPipelineInfo = pPipelineInfo;
|
|
|
|
params.pExecutableCount = pExecutableCount;
|
|
|
|
params.pProperties = pProperties;
|
|
|
|
return unix_funcs->p_vkGetPipelineExecutablePropertiesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPipelineExecutableStatisticsKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pExecutableInfo = pExecutableInfo;
|
|
|
|
params.pStatisticCount = pStatisticCount;
|
|
|
|
params.pStatistics = pStatistics;
|
|
|
|
return unix_funcs->p_vkGetPipelineExecutableStatisticsKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t *pData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetPrivateDataEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.objectType = objectType;
|
|
|
|
params.objectHandle = objectHandle;
|
|
|
|
params.privateDataSlot = privateDataSlot;
|
|
|
|
params.pData = pData;
|
|
|
|
unix_funcs->p_vkGetPrivateDataEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetQueryPoolResults_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.firstQuery = firstQuery;
|
|
|
|
params.queryCount = queryCount;
|
|
|
|
params.dataSize = dataSize;
|
|
|
|
params.pData = pData;
|
|
|
|
params.stride = stride;
|
|
|
|
params.flags = flags;
|
|
|
|
return unix_funcs->p_vkGetQueryPoolResults(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetQueueCheckpointData2NV_params params;
|
|
|
|
params.queue = queue;
|
|
|
|
params.pCheckpointDataCount = pCheckpointDataCount;
|
|
|
|
params.pCheckpointData = pCheckpointData;
|
|
|
|
unix_funcs->p_vkGetQueueCheckpointData2NV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetQueueCheckpointDataNV_params params;
|
|
|
|
params.queue = queue;
|
|
|
|
params.pCheckpointDataCount = pCheckpointDataCount;
|
|
|
|
params.pCheckpointData = pCheckpointData;
|
|
|
|
unix_funcs->p_vkGetQueueCheckpointDataNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipeline = pipeline;
|
|
|
|
params.firstGroup = firstGroup;
|
|
|
|
params.groupCount = groupCount;
|
|
|
|
params.dataSize = dataSize;
|
|
|
|
params.pData = pData;
|
|
|
|
return unix_funcs->p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetRayTracingShaderGroupHandlesKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipeline = pipeline;
|
|
|
|
params.firstGroup = firstGroup;
|
|
|
|
params.groupCount = groupCount;
|
|
|
|
params.dataSize = dataSize;
|
|
|
|
params.pData = pData;
|
|
|
|
return unix_funcs->p_vkGetRayTracingShaderGroupHandlesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetRayTracingShaderGroupHandlesNV_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipeline = pipeline;
|
|
|
|
params.firstGroup = firstGroup;
|
|
|
|
params.groupCount = groupCount;
|
|
|
|
params.dataSize = dataSize;
|
|
|
|
params.pData = pData;
|
|
|
|
return unix_funcs->p_vkGetRayTracingShaderGroupHandlesNV(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkDeviceSize WINAPI vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetRayTracingShaderGroupStackSizeKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipeline = pipeline;
|
|
|
|
params.group = group;
|
|
|
|
params.groupShader = groupShader;
|
|
|
|
return unix_funcs->p_vkGetRayTracingShaderGroupStackSizeKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetRenderAreaGranularity_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.renderPass = renderPass;
|
|
|
|
params.pGranularity = pGranularity;
|
|
|
|
unix_funcs->p_vkGetRenderAreaGranularity(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetSemaphoreCounterValue_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.semaphore = semaphore;
|
|
|
|
params.pValue = pValue;
|
|
|
|
return unix_funcs->p_vkGetSemaphoreCounterValue(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetSemaphoreCounterValueKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.semaphore = semaphore;
|
|
|
|
params.pValue = pValue;
|
|
|
|
return unix_funcs->p_vkGetSemaphoreCounterValueKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetShaderInfoAMD_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pipeline = pipeline;
|
|
|
|
params.shaderStage = shaderStage;
|
|
|
|
params.infoType = infoType;
|
|
|
|
params.pInfoSize = pInfoSize;
|
|
|
|
params.pInfo = pInfo;
|
|
|
|
return unix_funcs->p_vkGetShaderInfoAMD(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetSwapchainImagesKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.swapchain = swapchain;
|
|
|
|
params.pSwapchainImageCount = pSwapchainImageCount;
|
|
|
|
params.pSwapchainImages = pSwapchainImages;
|
|
|
|
return unix_funcs->p_vkGetSwapchainImagesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkGetValidationCacheDataEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.validationCache = validationCache;
|
|
|
|
params.pDataSize = pDataSize;
|
|
|
|
params.pData = pData;
|
|
|
|
return unix_funcs->p_vkGetValidationCacheDataEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkInitializePerformanceApiINTEL_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pInitializeInfo = pInitializeInfo;
|
|
|
|
return unix_funcs->p_vkInitializePerformanceApiINTEL(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkInvalidateMappedMemoryRanges_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.memoryRangeCount = memoryRangeCount;
|
|
|
|
params.pMemoryRanges = pMemoryRanges;
|
|
|
|
return unix_funcs->p_vkInvalidateMappedMemoryRanges(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkMapMemory_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.memory = memory;
|
|
|
|
params.offset = offset;
|
|
|
|
params.size = size;
|
|
|
|
params.flags = flags;
|
|
|
|
params.ppData = ppData;
|
|
|
|
return unix_funcs->p_vkMapMemory(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkMergePipelineCaches_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.dstCache = dstCache;
|
|
|
|
params.srcCacheCount = srcCacheCount;
|
|
|
|
params.pSrcCaches = pSrcCaches;
|
|
|
|
return unix_funcs->p_vkMergePipelineCaches(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkMergeValidationCachesEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.dstCache = dstCache;
|
|
|
|
params.srcCacheCount = srcCacheCount;
|
|
|
|
params.pSrcCaches = pSrcCaches;
|
|
|
|
return unix_funcs->p_vkMergeValidationCachesEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkQueueBeginDebugUtilsLabelEXT_params params;
|
|
|
|
params.queue = queue;
|
|
|
|
params.pLabelInfo = pLabelInfo;
|
|
|
|
unix_funcs->p_vkQueueBeginDebugUtilsLabelEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkQueueBindSparse_params params;
|
|
|
|
params.queue = queue;
|
|
|
|
params.bindInfoCount = bindInfoCount;
|
|
|
|
params.pBindInfo = pBindInfo;
|
|
|
|
params.fence = fence;
|
|
|
|
return unix_funcs->p_vkQueueBindSparse(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkQueueEndDebugUtilsLabelEXT_params params;
|
|
|
|
params.queue = queue;
|
|
|
|
unix_funcs->p_vkQueueEndDebugUtilsLabelEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkQueueInsertDebugUtilsLabelEXT_params params;
|
|
|
|
params.queue = queue;
|
|
|
|
params.pLabelInfo = pLabelInfo;
|
|
|
|
unix_funcs->p_vkQueueInsertDebugUtilsLabelEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkQueuePresentKHR_params params;
|
|
|
|
params.queue = queue;
|
|
|
|
params.pPresentInfo = pPresentInfo;
|
|
|
|
return unix_funcs->p_vkQueuePresentKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkQueueSetPerformanceConfigurationINTEL_params params;
|
|
|
|
params.queue = queue;
|
|
|
|
params.configuration = configuration;
|
|
|
|
return unix_funcs->p_vkQueueSetPerformanceConfigurationINTEL(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkQueueSubmit_params params;
|
|
|
|
params.queue = queue;
|
|
|
|
params.submitCount = submitCount;
|
|
|
|
params.pSubmits = pSubmits;
|
|
|
|
params.fence = fence;
|
|
|
|
return unix_funcs->p_vkQueueSubmit(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR *pSubmits, VkFence fence)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkQueueSubmit2KHR_params params;
|
|
|
|
params.queue = queue;
|
|
|
|
params.submitCount = submitCount;
|
|
|
|
params.pSubmits = pSubmits;
|
|
|
|
params.fence = fence;
|
|
|
|
return unix_funcs->p_vkQueueSubmit2KHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkQueueWaitIdle(VkQueue queue)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkQueueWaitIdle_params params;
|
|
|
|
params.queue = queue;
|
|
|
|
return unix_funcs->p_vkQueueWaitIdle(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkReleasePerformanceConfigurationINTEL_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.configuration = configuration;
|
|
|
|
return unix_funcs->p_vkReleasePerformanceConfigurationINTEL(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkReleaseProfilingLockKHR(VkDevice device)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkReleaseProfilingLockKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
unix_funcs->p_vkReleaseProfilingLockKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkResetCommandBuffer_params params;
|
|
|
|
params.commandBuffer = commandBuffer;
|
|
|
|
params.flags = flags;
|
|
|
|
return unix_funcs->p_vkResetCommandBuffer(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkResetCommandPool_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.commandPool = commandPool;
|
|
|
|
params.flags = flags;
|
|
|
|
return unix_funcs->p_vkResetCommandPool(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkResetDescriptorPool_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.descriptorPool = descriptorPool;
|
|
|
|
params.flags = flags;
|
|
|
|
return unix_funcs->p_vkResetDescriptorPool(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkResetEvent(VkDevice device, VkEvent event)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkResetEvent_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.event = event;
|
|
|
|
return unix_funcs->p_vkResetEvent(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkResetFences_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.fenceCount = fenceCount;
|
|
|
|
params.pFences = pFences;
|
|
|
|
return unix_funcs->p_vkResetFences(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkResetQueryPool_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.firstQuery = firstQuery;
|
|
|
|
params.queryCount = queryCount;
|
|
|
|
unix_funcs->p_vkResetQueryPool(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkResetQueryPoolEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.queryPool = queryPool;
|
|
|
|
params.firstQuery = firstQuery;
|
|
|
|
params.queryCount = queryCount;
|
|
|
|
unix_funcs->p_vkResetQueryPoolEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkSetDebugUtilsObjectNameEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pNameInfo = pNameInfo;
|
|
|
|
return unix_funcs->p_vkSetDebugUtilsObjectNameEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkSetDebugUtilsObjectTagEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pTagInfo = pTagInfo;
|
|
|
|
return unix_funcs->p_vkSetDebugUtilsObjectTagEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-09-07 21:39:18 +02:00
|
|
|
void WINAPI vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkSetDeviceMemoryPriorityEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.memory = memory;
|
|
|
|
params.priority = priority;
|
|
|
|
unix_funcs->p_vkSetDeviceMemoryPriorityEXT(¶ms);
|
2021-09-07 21:39:18 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkSetEvent(VkDevice device, VkEvent event)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkSetEvent_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.event = event;
|
|
|
|
return unix_funcs->p_vkSetEvent(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkSetPrivateDataEXT_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.objectType = objectType;
|
|
|
|
params.objectHandle = objectHandle;
|
|
|
|
params.privateDataSlot = privateDataSlot;
|
|
|
|
params.data = data;
|
|
|
|
return unix_funcs->p_vkSetPrivateDataEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkSignalSemaphore_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pSignalInfo = pSignalInfo;
|
|
|
|
return unix_funcs->p_vkSignalSemaphore(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkSignalSemaphoreKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pSignalInfo = pSignalInfo;
|
|
|
|
return unix_funcs->p_vkSignalSemaphoreKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkSubmitDebugUtilsMessageEXT_params params;
|
|
|
|
params.instance = instance;
|
|
|
|
params.messageSeverity = messageSeverity;
|
|
|
|
params.messageTypes = messageTypes;
|
|
|
|
params.pCallbackData = pCallbackData;
|
|
|
|
unix_funcs->p_vkSubmitDebugUtilsMessageEXT(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkTrimCommandPool_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.commandPool = commandPool;
|
|
|
|
params.flags = flags;
|
|
|
|
unix_funcs->p_vkTrimCommandPool(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkTrimCommandPoolKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.commandPool = commandPool;
|
|
|
|
params.flags = flags;
|
|
|
|
unix_funcs->p_vkTrimCommandPoolKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkUninitializePerformanceApiINTEL(VkDevice device)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkUninitializePerformanceApiINTEL_params params;
|
|
|
|
params.device = device;
|
|
|
|
unix_funcs->p_vkUninitializePerformanceApiINTEL(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkUnmapMemory_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.memory = memory;
|
|
|
|
unix_funcs->p_vkUnmapMemory(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkUpdateDescriptorSetWithTemplate_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.descriptorSet = descriptorSet;
|
|
|
|
params.descriptorUpdateTemplate = descriptorUpdateTemplate;
|
|
|
|
params.pData = pData;
|
|
|
|
unix_funcs->p_vkUpdateDescriptorSetWithTemplate(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkUpdateDescriptorSetWithTemplateKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.descriptorSet = descriptorSet;
|
|
|
|
params.descriptorUpdateTemplate = descriptorUpdateTemplate;
|
|
|
|
params.pData = pData;
|
|
|
|
unix_funcs->p_vkUpdateDescriptorSetWithTemplateKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
void WINAPI vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkUpdateDescriptorSets_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.descriptorWriteCount = descriptorWriteCount;
|
|
|
|
params.pDescriptorWrites = pDescriptorWrites;
|
|
|
|
params.descriptorCopyCount = descriptorCopyCount;
|
|
|
|
params.pDescriptorCopies = pDescriptorCopies;
|
|
|
|
unix_funcs->p_vkUpdateDescriptorSets(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkWaitForFences_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.fenceCount = fenceCount;
|
|
|
|
params.pFences = pFences;
|
|
|
|
params.waitAll = waitAll;
|
|
|
|
params.timeout = timeout;
|
|
|
|
return unix_funcs->p_vkWaitForFences(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-07-20 15:04:48 +02:00
|
|
|
VkResult WINAPI vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
|
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkWaitForPresentKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.swapchain = swapchain;
|
|
|
|
params.presentId = presentId;
|
|
|
|
params.timeout = timeout;
|
|
|
|
return unix_funcs->p_vkWaitForPresentKHR(¶ms);
|
2021-07-20 15:04:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkWaitSemaphores_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pWaitInfo = pWaitInfo;
|
|
|
|
params.timeout = timeout;
|
|
|
|
return unix_funcs->p_vkWaitSemaphores(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkWaitSemaphoresKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.pWaitInfo = pWaitInfo;
|
|
|
|
params.timeout = timeout;
|
|
|
|
return unix_funcs->p_vkWaitSemaphoresKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
2021-04-29 14:38:50 +02:00
|
|
|
VkResult WINAPI vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
|
2021-04-16 15:48:48 +02:00
|
|
|
{
|
2021-12-10 18:40:42 +01:00
|
|
|
struct vkWriteAccelerationStructuresPropertiesKHR_params params;
|
|
|
|
params.device = device;
|
|
|
|
params.accelerationStructureCount = accelerationStructureCount;
|
|
|
|
params.pAccelerationStructures = pAccelerationStructures;
|
|
|
|
params.queryType = queryType;
|
|
|
|
params.dataSize = dataSize;
|
|
|
|
params.pData = pData;
|
|
|
|
params.stride = stride;
|
|
|
|
return unix_funcs->p_vkWriteAccelerationStructuresPropertiesKHR(¶ms);
|
2021-04-16 15:48:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct vulkan_func vk_device_dispatch_table[] =
|
|
|
|
{
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkAcquireNextImage2KHR", &vkAcquireNextImage2KHR},
|
|
|
|
{"vkAcquireNextImageKHR", &vkAcquireNextImageKHR},
|
|
|
|
{"vkAcquirePerformanceConfigurationINTEL", &vkAcquirePerformanceConfigurationINTEL},
|
|
|
|
{"vkAcquireProfilingLockKHR", &vkAcquireProfilingLockKHR},
|
|
|
|
{"vkAllocateCommandBuffers", &vkAllocateCommandBuffers},
|
|
|
|
{"vkAllocateDescriptorSets", &vkAllocateDescriptorSets},
|
|
|
|
{"vkAllocateMemory", &vkAllocateMemory},
|
|
|
|
{"vkBeginCommandBuffer", &vkBeginCommandBuffer},
|
|
|
|
{"vkBindAccelerationStructureMemoryNV", &vkBindAccelerationStructureMemoryNV},
|
|
|
|
{"vkBindBufferMemory", &vkBindBufferMemory},
|
|
|
|
{"vkBindBufferMemory2", &vkBindBufferMemory2},
|
|
|
|
{"vkBindBufferMemory2KHR", &vkBindBufferMemory2KHR},
|
|
|
|
{"vkBindImageMemory", &vkBindImageMemory},
|
|
|
|
{"vkBindImageMemory2", &vkBindImageMemory2},
|
|
|
|
{"vkBindImageMemory2KHR", &vkBindImageMemory2KHR},
|
|
|
|
{"vkBuildAccelerationStructuresKHR", &vkBuildAccelerationStructuresKHR},
|
|
|
|
{"vkCmdBeginConditionalRenderingEXT", &vkCmdBeginConditionalRenderingEXT},
|
|
|
|
{"vkCmdBeginDebugUtilsLabelEXT", &vkCmdBeginDebugUtilsLabelEXT},
|
|
|
|
{"vkCmdBeginQuery", &vkCmdBeginQuery},
|
|
|
|
{"vkCmdBeginQueryIndexedEXT", &vkCmdBeginQueryIndexedEXT},
|
|
|
|
{"vkCmdBeginRenderPass", &vkCmdBeginRenderPass},
|
|
|
|
{"vkCmdBeginRenderPass2", &vkCmdBeginRenderPass2},
|
|
|
|
{"vkCmdBeginRenderPass2KHR", &vkCmdBeginRenderPass2KHR},
|
2021-11-02 11:59:57 +01:00
|
|
|
{"vkCmdBeginRenderingKHR", &vkCmdBeginRenderingKHR},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkCmdBeginTransformFeedbackEXT", &vkCmdBeginTransformFeedbackEXT},
|
|
|
|
{"vkCmdBindDescriptorSets", &vkCmdBindDescriptorSets},
|
|
|
|
{"vkCmdBindIndexBuffer", &vkCmdBindIndexBuffer},
|
2021-07-20 15:04:48 +02:00
|
|
|
{"vkCmdBindInvocationMaskHUAWEI", &vkCmdBindInvocationMaskHUAWEI},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkCmdBindPipeline", &vkCmdBindPipeline},
|
|
|
|
{"vkCmdBindPipelineShaderGroupNV", &vkCmdBindPipelineShaderGroupNV},
|
|
|
|
{"vkCmdBindShadingRateImageNV", &vkCmdBindShadingRateImageNV},
|
|
|
|
{"vkCmdBindTransformFeedbackBuffersEXT", &vkCmdBindTransformFeedbackBuffersEXT},
|
|
|
|
{"vkCmdBindVertexBuffers", &vkCmdBindVertexBuffers},
|
|
|
|
{"vkCmdBindVertexBuffers2EXT", &vkCmdBindVertexBuffers2EXT},
|
|
|
|
{"vkCmdBlitImage", &vkCmdBlitImage},
|
|
|
|
{"vkCmdBlitImage2KHR", &vkCmdBlitImage2KHR},
|
|
|
|
{"vkCmdBuildAccelerationStructureNV", &vkCmdBuildAccelerationStructureNV},
|
|
|
|
{"vkCmdBuildAccelerationStructuresIndirectKHR", &vkCmdBuildAccelerationStructuresIndirectKHR},
|
|
|
|
{"vkCmdBuildAccelerationStructuresKHR", &vkCmdBuildAccelerationStructuresKHR},
|
|
|
|
{"vkCmdClearAttachments", &vkCmdClearAttachments},
|
|
|
|
{"vkCmdClearColorImage", &vkCmdClearColorImage},
|
|
|
|
{"vkCmdClearDepthStencilImage", &vkCmdClearDepthStencilImage},
|
|
|
|
{"vkCmdCopyAccelerationStructureKHR", &vkCmdCopyAccelerationStructureKHR},
|
|
|
|
{"vkCmdCopyAccelerationStructureNV", &vkCmdCopyAccelerationStructureNV},
|
|
|
|
{"vkCmdCopyAccelerationStructureToMemoryKHR", &vkCmdCopyAccelerationStructureToMemoryKHR},
|
|
|
|
{"vkCmdCopyBuffer", &vkCmdCopyBuffer},
|
|
|
|
{"vkCmdCopyBuffer2KHR", &vkCmdCopyBuffer2KHR},
|
|
|
|
{"vkCmdCopyBufferToImage", &vkCmdCopyBufferToImage},
|
|
|
|
{"vkCmdCopyBufferToImage2KHR", &vkCmdCopyBufferToImage2KHR},
|
|
|
|
{"vkCmdCopyImage", &vkCmdCopyImage},
|
|
|
|
{"vkCmdCopyImage2KHR", &vkCmdCopyImage2KHR},
|
|
|
|
{"vkCmdCopyImageToBuffer", &vkCmdCopyImageToBuffer},
|
|
|
|
{"vkCmdCopyImageToBuffer2KHR", &vkCmdCopyImageToBuffer2KHR},
|
|
|
|
{"vkCmdCopyMemoryToAccelerationStructureKHR", &vkCmdCopyMemoryToAccelerationStructureKHR},
|
|
|
|
{"vkCmdCopyQueryPoolResults", &vkCmdCopyQueryPoolResults},
|
2021-05-10 12:29:08 +02:00
|
|
|
{"vkCmdCuLaunchKernelNVX", &vkCmdCuLaunchKernelNVX},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkCmdDebugMarkerBeginEXT", &vkCmdDebugMarkerBeginEXT},
|
|
|
|
{"vkCmdDebugMarkerEndEXT", &vkCmdDebugMarkerEndEXT},
|
|
|
|
{"vkCmdDebugMarkerInsertEXT", &vkCmdDebugMarkerInsertEXT},
|
|
|
|
{"vkCmdDispatch", &vkCmdDispatch},
|
|
|
|
{"vkCmdDispatchBase", &vkCmdDispatchBase},
|
|
|
|
{"vkCmdDispatchBaseKHR", &vkCmdDispatchBaseKHR},
|
|
|
|
{"vkCmdDispatchIndirect", &vkCmdDispatchIndirect},
|
|
|
|
{"vkCmdDraw", &vkCmdDraw},
|
|
|
|
{"vkCmdDrawIndexed", &vkCmdDrawIndexed},
|
|
|
|
{"vkCmdDrawIndexedIndirect", &vkCmdDrawIndexedIndirect},
|
|
|
|
{"vkCmdDrawIndexedIndirectCount", &vkCmdDrawIndexedIndirectCount},
|
|
|
|
{"vkCmdDrawIndexedIndirectCountAMD", &vkCmdDrawIndexedIndirectCountAMD},
|
|
|
|
{"vkCmdDrawIndexedIndirectCountKHR", &vkCmdDrawIndexedIndirectCountKHR},
|
|
|
|
{"vkCmdDrawIndirect", &vkCmdDrawIndirect},
|
|
|
|
{"vkCmdDrawIndirectByteCountEXT", &vkCmdDrawIndirectByteCountEXT},
|
|
|
|
{"vkCmdDrawIndirectCount", &vkCmdDrawIndirectCount},
|
|
|
|
{"vkCmdDrawIndirectCountAMD", &vkCmdDrawIndirectCountAMD},
|
|
|
|
{"vkCmdDrawIndirectCountKHR", &vkCmdDrawIndirectCountKHR},
|
|
|
|
{"vkCmdDrawMeshTasksIndirectCountNV", &vkCmdDrawMeshTasksIndirectCountNV},
|
|
|
|
{"vkCmdDrawMeshTasksIndirectNV", &vkCmdDrawMeshTasksIndirectNV},
|
|
|
|
{"vkCmdDrawMeshTasksNV", &vkCmdDrawMeshTasksNV},
|
2021-06-21 11:03:22 +02:00
|
|
|
{"vkCmdDrawMultiEXT", &vkCmdDrawMultiEXT},
|
|
|
|
{"vkCmdDrawMultiIndexedEXT", &vkCmdDrawMultiIndexedEXT},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkCmdEndConditionalRenderingEXT", &vkCmdEndConditionalRenderingEXT},
|
|
|
|
{"vkCmdEndDebugUtilsLabelEXT", &vkCmdEndDebugUtilsLabelEXT},
|
|
|
|
{"vkCmdEndQuery", &vkCmdEndQuery},
|
|
|
|
{"vkCmdEndQueryIndexedEXT", &vkCmdEndQueryIndexedEXT},
|
|
|
|
{"vkCmdEndRenderPass", &vkCmdEndRenderPass},
|
|
|
|
{"vkCmdEndRenderPass2", &vkCmdEndRenderPass2},
|
|
|
|
{"vkCmdEndRenderPass2KHR", &vkCmdEndRenderPass2KHR},
|
2021-11-02 11:59:57 +01:00
|
|
|
{"vkCmdEndRenderingKHR", &vkCmdEndRenderingKHR},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkCmdEndTransformFeedbackEXT", &vkCmdEndTransformFeedbackEXT},
|
|
|
|
{"vkCmdExecuteCommands", &vkCmdExecuteCommands},
|
|
|
|
{"vkCmdExecuteGeneratedCommandsNV", &vkCmdExecuteGeneratedCommandsNV},
|
|
|
|
{"vkCmdFillBuffer", &vkCmdFillBuffer},
|
|
|
|
{"vkCmdInsertDebugUtilsLabelEXT", &vkCmdInsertDebugUtilsLabelEXT},
|
|
|
|
{"vkCmdNextSubpass", &vkCmdNextSubpass},
|
|
|
|
{"vkCmdNextSubpass2", &vkCmdNextSubpass2},
|
|
|
|
{"vkCmdNextSubpass2KHR", &vkCmdNextSubpass2KHR},
|
|
|
|
{"vkCmdPipelineBarrier", &vkCmdPipelineBarrier},
|
|
|
|
{"vkCmdPipelineBarrier2KHR", &vkCmdPipelineBarrier2KHR},
|
|
|
|
{"vkCmdPreprocessGeneratedCommandsNV", &vkCmdPreprocessGeneratedCommandsNV},
|
|
|
|
{"vkCmdPushConstants", &vkCmdPushConstants},
|
|
|
|
{"vkCmdPushDescriptorSetKHR", &vkCmdPushDescriptorSetKHR},
|
|
|
|
{"vkCmdPushDescriptorSetWithTemplateKHR", &vkCmdPushDescriptorSetWithTemplateKHR},
|
|
|
|
{"vkCmdResetEvent", &vkCmdResetEvent},
|
|
|
|
{"vkCmdResetEvent2KHR", &vkCmdResetEvent2KHR},
|
|
|
|
{"vkCmdResetQueryPool", &vkCmdResetQueryPool},
|
|
|
|
{"vkCmdResolveImage", &vkCmdResolveImage},
|
|
|
|
{"vkCmdResolveImage2KHR", &vkCmdResolveImage2KHR},
|
|
|
|
{"vkCmdSetBlendConstants", &vkCmdSetBlendConstants},
|
|
|
|
{"vkCmdSetCheckpointNV", &vkCmdSetCheckpointNV},
|
|
|
|
{"vkCmdSetCoarseSampleOrderNV", &vkCmdSetCoarseSampleOrderNV},
|
|
|
|
{"vkCmdSetColorWriteEnableEXT", &vkCmdSetColorWriteEnableEXT},
|
|
|
|
{"vkCmdSetCullModeEXT", &vkCmdSetCullModeEXT},
|
|
|
|
{"vkCmdSetDepthBias", &vkCmdSetDepthBias},
|
|
|
|
{"vkCmdSetDepthBiasEnableEXT", &vkCmdSetDepthBiasEnableEXT},
|
|
|
|
{"vkCmdSetDepthBounds", &vkCmdSetDepthBounds},
|
|
|
|
{"vkCmdSetDepthBoundsTestEnableEXT", &vkCmdSetDepthBoundsTestEnableEXT},
|
|
|
|
{"vkCmdSetDepthCompareOpEXT", &vkCmdSetDepthCompareOpEXT},
|
|
|
|
{"vkCmdSetDepthTestEnableEXT", &vkCmdSetDepthTestEnableEXT},
|
|
|
|
{"vkCmdSetDepthWriteEnableEXT", &vkCmdSetDepthWriteEnableEXT},
|
|
|
|
{"vkCmdSetDeviceMask", &vkCmdSetDeviceMask},
|
|
|
|
{"vkCmdSetDeviceMaskKHR", &vkCmdSetDeviceMaskKHR},
|
|
|
|
{"vkCmdSetDiscardRectangleEXT", &vkCmdSetDiscardRectangleEXT},
|
|
|
|
{"vkCmdSetEvent", &vkCmdSetEvent},
|
|
|
|
{"vkCmdSetEvent2KHR", &vkCmdSetEvent2KHR},
|
|
|
|
{"vkCmdSetExclusiveScissorNV", &vkCmdSetExclusiveScissorNV},
|
|
|
|
{"vkCmdSetFragmentShadingRateEnumNV", &vkCmdSetFragmentShadingRateEnumNV},
|
|
|
|
{"vkCmdSetFragmentShadingRateKHR", &vkCmdSetFragmentShadingRateKHR},
|
|
|
|
{"vkCmdSetFrontFaceEXT", &vkCmdSetFrontFaceEXT},
|
|
|
|
{"vkCmdSetLineStippleEXT", &vkCmdSetLineStippleEXT},
|
|
|
|
{"vkCmdSetLineWidth", &vkCmdSetLineWidth},
|
|
|
|
{"vkCmdSetLogicOpEXT", &vkCmdSetLogicOpEXT},
|
|
|
|
{"vkCmdSetPatchControlPointsEXT", &vkCmdSetPatchControlPointsEXT},
|
|
|
|
{"vkCmdSetPerformanceMarkerINTEL", &vkCmdSetPerformanceMarkerINTEL},
|
|
|
|
{"vkCmdSetPerformanceOverrideINTEL", &vkCmdSetPerformanceOverrideINTEL},
|
|
|
|
{"vkCmdSetPerformanceStreamMarkerINTEL", &vkCmdSetPerformanceStreamMarkerINTEL},
|
|
|
|
{"vkCmdSetPrimitiveRestartEnableEXT", &vkCmdSetPrimitiveRestartEnableEXT},
|
|
|
|
{"vkCmdSetPrimitiveTopologyEXT", &vkCmdSetPrimitiveTopologyEXT},
|
|
|
|
{"vkCmdSetRasterizerDiscardEnableEXT", &vkCmdSetRasterizerDiscardEnableEXT},
|
|
|
|
{"vkCmdSetRayTracingPipelineStackSizeKHR", &vkCmdSetRayTracingPipelineStackSizeKHR},
|
|
|
|
{"vkCmdSetSampleLocationsEXT", &vkCmdSetSampleLocationsEXT},
|
|
|
|
{"vkCmdSetScissor", &vkCmdSetScissor},
|
|
|
|
{"vkCmdSetScissorWithCountEXT", &vkCmdSetScissorWithCountEXT},
|
|
|
|
{"vkCmdSetStencilCompareMask", &vkCmdSetStencilCompareMask},
|
|
|
|
{"vkCmdSetStencilOpEXT", &vkCmdSetStencilOpEXT},
|
|
|
|
{"vkCmdSetStencilReference", &vkCmdSetStencilReference},
|
|
|
|
{"vkCmdSetStencilTestEnableEXT", &vkCmdSetStencilTestEnableEXT},
|
|
|
|
{"vkCmdSetStencilWriteMask", &vkCmdSetStencilWriteMask},
|
|
|
|
{"vkCmdSetVertexInputEXT", &vkCmdSetVertexInputEXT},
|
|
|
|
{"vkCmdSetViewport", &vkCmdSetViewport},
|
|
|
|
{"vkCmdSetViewportShadingRatePaletteNV", &vkCmdSetViewportShadingRatePaletteNV},
|
|
|
|
{"vkCmdSetViewportWScalingNV", &vkCmdSetViewportWScalingNV},
|
|
|
|
{"vkCmdSetViewportWithCountEXT", &vkCmdSetViewportWithCountEXT},
|
2021-07-20 15:04:49 +02:00
|
|
|
{"vkCmdSubpassShadingHUAWEI", &vkCmdSubpassShadingHUAWEI},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkCmdTraceRaysIndirectKHR", &vkCmdTraceRaysIndirectKHR},
|
|
|
|
{"vkCmdTraceRaysKHR", &vkCmdTraceRaysKHR},
|
|
|
|
{"vkCmdTraceRaysNV", &vkCmdTraceRaysNV},
|
|
|
|
{"vkCmdUpdateBuffer", &vkCmdUpdateBuffer},
|
|
|
|
{"vkCmdWaitEvents", &vkCmdWaitEvents},
|
|
|
|
{"vkCmdWaitEvents2KHR", &vkCmdWaitEvents2KHR},
|
|
|
|
{"vkCmdWriteAccelerationStructuresPropertiesKHR", &vkCmdWriteAccelerationStructuresPropertiesKHR},
|
|
|
|
{"vkCmdWriteAccelerationStructuresPropertiesNV", &vkCmdWriteAccelerationStructuresPropertiesNV},
|
|
|
|
{"vkCmdWriteBufferMarker2AMD", &vkCmdWriteBufferMarker2AMD},
|
|
|
|
{"vkCmdWriteBufferMarkerAMD", &vkCmdWriteBufferMarkerAMD},
|
|
|
|
{"vkCmdWriteTimestamp", &vkCmdWriteTimestamp},
|
|
|
|
{"vkCmdWriteTimestamp2KHR", &vkCmdWriteTimestamp2KHR},
|
|
|
|
{"vkCompileDeferredNV", &vkCompileDeferredNV},
|
|
|
|
{"vkCopyAccelerationStructureKHR", &vkCopyAccelerationStructureKHR},
|
|
|
|
{"vkCopyAccelerationStructureToMemoryKHR", &vkCopyAccelerationStructureToMemoryKHR},
|
|
|
|
{"vkCopyMemoryToAccelerationStructureKHR", &vkCopyMemoryToAccelerationStructureKHR},
|
|
|
|
{"vkCreateAccelerationStructureKHR", &vkCreateAccelerationStructureKHR},
|
|
|
|
{"vkCreateAccelerationStructureNV", &vkCreateAccelerationStructureNV},
|
|
|
|
{"vkCreateBuffer", &vkCreateBuffer},
|
|
|
|
{"vkCreateBufferView", &vkCreateBufferView},
|
|
|
|
{"vkCreateCommandPool", &vkCreateCommandPool},
|
|
|
|
{"vkCreateComputePipelines", &vkCreateComputePipelines},
|
2021-05-10 12:29:08 +02:00
|
|
|
{"vkCreateCuFunctionNVX", &vkCreateCuFunctionNVX},
|
|
|
|
{"vkCreateCuModuleNVX", &vkCreateCuModuleNVX},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkCreateDeferredOperationKHR", &vkCreateDeferredOperationKHR},
|
|
|
|
{"vkCreateDescriptorPool", &vkCreateDescriptorPool},
|
|
|
|
{"vkCreateDescriptorSetLayout", &vkCreateDescriptorSetLayout},
|
|
|
|
{"vkCreateDescriptorUpdateTemplate", &vkCreateDescriptorUpdateTemplate},
|
|
|
|
{"vkCreateDescriptorUpdateTemplateKHR", &vkCreateDescriptorUpdateTemplateKHR},
|
|
|
|
{"vkCreateEvent", &vkCreateEvent},
|
|
|
|
{"vkCreateFence", &vkCreateFence},
|
|
|
|
{"vkCreateFramebuffer", &vkCreateFramebuffer},
|
|
|
|
{"vkCreateGraphicsPipelines", &vkCreateGraphicsPipelines},
|
|
|
|
{"vkCreateImage", &vkCreateImage},
|
|
|
|
{"vkCreateImageView", &vkCreateImageView},
|
|
|
|
{"vkCreateIndirectCommandsLayoutNV", &vkCreateIndirectCommandsLayoutNV},
|
|
|
|
{"vkCreatePipelineCache", &vkCreatePipelineCache},
|
|
|
|
{"vkCreatePipelineLayout", &vkCreatePipelineLayout},
|
|
|
|
{"vkCreatePrivateDataSlotEXT", &vkCreatePrivateDataSlotEXT},
|
|
|
|
{"vkCreateQueryPool", &vkCreateQueryPool},
|
|
|
|
{"vkCreateRayTracingPipelinesKHR", &vkCreateRayTracingPipelinesKHR},
|
|
|
|
{"vkCreateRayTracingPipelinesNV", &vkCreateRayTracingPipelinesNV},
|
|
|
|
{"vkCreateRenderPass", &vkCreateRenderPass},
|
|
|
|
{"vkCreateRenderPass2", &vkCreateRenderPass2},
|
|
|
|
{"vkCreateRenderPass2KHR", &vkCreateRenderPass2KHR},
|
|
|
|
{"vkCreateSampler", &vkCreateSampler},
|
|
|
|
{"vkCreateSamplerYcbcrConversion", &vkCreateSamplerYcbcrConversion},
|
|
|
|
{"vkCreateSamplerYcbcrConversionKHR", &vkCreateSamplerYcbcrConversionKHR},
|
|
|
|
{"vkCreateSemaphore", &vkCreateSemaphore},
|
|
|
|
{"vkCreateShaderModule", &vkCreateShaderModule},
|
|
|
|
{"vkCreateSwapchainKHR", &vkCreateSwapchainKHR},
|
|
|
|
{"vkCreateValidationCacheEXT", &vkCreateValidationCacheEXT},
|
|
|
|
{"vkDebugMarkerSetObjectNameEXT", &vkDebugMarkerSetObjectNameEXT},
|
|
|
|
{"vkDebugMarkerSetObjectTagEXT", &vkDebugMarkerSetObjectTagEXT},
|
|
|
|
{"vkDeferredOperationJoinKHR", &vkDeferredOperationJoinKHR},
|
|
|
|
{"vkDestroyAccelerationStructureKHR", &vkDestroyAccelerationStructureKHR},
|
|
|
|
{"vkDestroyAccelerationStructureNV", &vkDestroyAccelerationStructureNV},
|
|
|
|
{"vkDestroyBuffer", &vkDestroyBuffer},
|
|
|
|
{"vkDestroyBufferView", &vkDestroyBufferView},
|
|
|
|
{"vkDestroyCommandPool", &vkDestroyCommandPool},
|
2021-05-10 12:29:08 +02:00
|
|
|
{"vkDestroyCuFunctionNVX", &vkDestroyCuFunctionNVX},
|
|
|
|
{"vkDestroyCuModuleNVX", &vkDestroyCuModuleNVX},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkDestroyDeferredOperationKHR", &vkDestroyDeferredOperationKHR},
|
|
|
|
{"vkDestroyDescriptorPool", &vkDestroyDescriptorPool},
|
|
|
|
{"vkDestroyDescriptorSetLayout", &vkDestroyDescriptorSetLayout},
|
|
|
|
{"vkDestroyDescriptorUpdateTemplate", &vkDestroyDescriptorUpdateTemplate},
|
|
|
|
{"vkDestroyDescriptorUpdateTemplateKHR", &vkDestroyDescriptorUpdateTemplateKHR},
|
|
|
|
{"vkDestroyDevice", &vkDestroyDevice},
|
|
|
|
{"vkDestroyEvent", &vkDestroyEvent},
|
|
|
|
{"vkDestroyFence", &vkDestroyFence},
|
|
|
|
{"vkDestroyFramebuffer", &vkDestroyFramebuffer},
|
|
|
|
{"vkDestroyImage", &vkDestroyImage},
|
|
|
|
{"vkDestroyImageView", &vkDestroyImageView},
|
|
|
|
{"vkDestroyIndirectCommandsLayoutNV", &vkDestroyIndirectCommandsLayoutNV},
|
|
|
|
{"vkDestroyPipeline", &vkDestroyPipeline},
|
|
|
|
{"vkDestroyPipelineCache", &vkDestroyPipelineCache},
|
|
|
|
{"vkDestroyPipelineLayout", &vkDestroyPipelineLayout},
|
|
|
|
{"vkDestroyPrivateDataSlotEXT", &vkDestroyPrivateDataSlotEXT},
|
|
|
|
{"vkDestroyQueryPool", &vkDestroyQueryPool},
|
|
|
|
{"vkDestroyRenderPass", &vkDestroyRenderPass},
|
|
|
|
{"vkDestroySampler", &vkDestroySampler},
|
|
|
|
{"vkDestroySamplerYcbcrConversion", &vkDestroySamplerYcbcrConversion},
|
|
|
|
{"vkDestroySamplerYcbcrConversionKHR", &vkDestroySamplerYcbcrConversionKHR},
|
|
|
|
{"vkDestroySemaphore", &vkDestroySemaphore},
|
|
|
|
{"vkDestroyShaderModule", &vkDestroyShaderModule},
|
|
|
|
{"vkDestroySwapchainKHR", &vkDestroySwapchainKHR},
|
|
|
|
{"vkDestroyValidationCacheEXT", &vkDestroyValidationCacheEXT},
|
|
|
|
{"vkDeviceWaitIdle", &vkDeviceWaitIdle},
|
|
|
|
{"vkEndCommandBuffer", &vkEndCommandBuffer},
|
|
|
|
{"vkFlushMappedMemoryRanges", &vkFlushMappedMemoryRanges},
|
|
|
|
{"vkFreeCommandBuffers", &vkFreeCommandBuffers},
|
|
|
|
{"vkFreeDescriptorSets", &vkFreeDescriptorSets},
|
|
|
|
{"vkFreeMemory", &vkFreeMemory},
|
|
|
|
{"vkGetAccelerationStructureBuildSizesKHR", &vkGetAccelerationStructureBuildSizesKHR},
|
|
|
|
{"vkGetAccelerationStructureDeviceAddressKHR", &vkGetAccelerationStructureDeviceAddressKHR},
|
|
|
|
{"vkGetAccelerationStructureHandleNV", &vkGetAccelerationStructureHandleNV},
|
|
|
|
{"vkGetAccelerationStructureMemoryRequirementsNV", &vkGetAccelerationStructureMemoryRequirementsNV},
|
|
|
|
{"vkGetBufferDeviceAddress", &vkGetBufferDeviceAddress},
|
|
|
|
{"vkGetBufferDeviceAddressEXT", &vkGetBufferDeviceAddressEXT},
|
|
|
|
{"vkGetBufferDeviceAddressKHR", &vkGetBufferDeviceAddressKHR},
|
|
|
|
{"vkGetBufferMemoryRequirements", &vkGetBufferMemoryRequirements},
|
|
|
|
{"vkGetBufferMemoryRequirements2", &vkGetBufferMemoryRequirements2},
|
|
|
|
{"vkGetBufferMemoryRequirements2KHR", &vkGetBufferMemoryRequirements2KHR},
|
|
|
|
{"vkGetBufferOpaqueCaptureAddress", &vkGetBufferOpaqueCaptureAddress},
|
|
|
|
{"vkGetBufferOpaqueCaptureAddressKHR", &vkGetBufferOpaqueCaptureAddressKHR},
|
|
|
|
{"vkGetCalibratedTimestampsEXT", &vkGetCalibratedTimestampsEXT},
|
|
|
|
{"vkGetDeferredOperationMaxConcurrencyKHR", &vkGetDeferredOperationMaxConcurrencyKHR},
|
|
|
|
{"vkGetDeferredOperationResultKHR", &vkGetDeferredOperationResultKHR},
|
|
|
|
{"vkGetDescriptorSetLayoutSupport", &vkGetDescriptorSetLayoutSupport},
|
|
|
|
{"vkGetDescriptorSetLayoutSupportKHR", &vkGetDescriptorSetLayoutSupportKHR},
|
|
|
|
{"vkGetDeviceAccelerationStructureCompatibilityKHR", &vkGetDeviceAccelerationStructureCompatibilityKHR},
|
2021-10-05 15:40:37 +02:00
|
|
|
{"vkGetDeviceBufferMemoryRequirementsKHR", &vkGetDeviceBufferMemoryRequirementsKHR},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkGetDeviceGroupPeerMemoryFeatures", &vkGetDeviceGroupPeerMemoryFeatures},
|
|
|
|
{"vkGetDeviceGroupPeerMemoryFeaturesKHR", &vkGetDeviceGroupPeerMemoryFeaturesKHR},
|
|
|
|
{"vkGetDeviceGroupPresentCapabilitiesKHR", &vkGetDeviceGroupPresentCapabilitiesKHR},
|
|
|
|
{"vkGetDeviceGroupSurfacePresentModesKHR", &vkGetDeviceGroupSurfacePresentModesKHR},
|
2021-10-05 15:40:37 +02:00
|
|
|
{"vkGetDeviceImageMemoryRequirementsKHR", &vkGetDeviceImageMemoryRequirementsKHR},
|
|
|
|
{"vkGetDeviceImageSparseMemoryRequirementsKHR", &vkGetDeviceImageSparseMemoryRequirementsKHR},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkGetDeviceMemoryCommitment", &vkGetDeviceMemoryCommitment},
|
|
|
|
{"vkGetDeviceMemoryOpaqueCaptureAddress", &vkGetDeviceMemoryOpaqueCaptureAddress},
|
|
|
|
{"vkGetDeviceMemoryOpaqueCaptureAddressKHR", &vkGetDeviceMemoryOpaqueCaptureAddressKHR},
|
|
|
|
{"vkGetDeviceProcAddr", &vkGetDeviceProcAddr},
|
|
|
|
{"vkGetDeviceQueue", &vkGetDeviceQueue},
|
|
|
|
{"vkGetDeviceQueue2", &vkGetDeviceQueue2},
|
2021-07-20 15:04:49 +02:00
|
|
|
{"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", &vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkGetEventStatus", &vkGetEventStatus},
|
|
|
|
{"vkGetFenceStatus", &vkGetFenceStatus},
|
|
|
|
{"vkGetGeneratedCommandsMemoryRequirementsNV", &vkGetGeneratedCommandsMemoryRequirementsNV},
|
|
|
|
{"vkGetImageMemoryRequirements", &vkGetImageMemoryRequirements},
|
|
|
|
{"vkGetImageMemoryRequirements2", &vkGetImageMemoryRequirements2},
|
|
|
|
{"vkGetImageMemoryRequirements2KHR", &vkGetImageMemoryRequirements2KHR},
|
|
|
|
{"vkGetImageSparseMemoryRequirements", &vkGetImageSparseMemoryRequirements},
|
|
|
|
{"vkGetImageSparseMemoryRequirements2", &vkGetImageSparseMemoryRequirements2},
|
|
|
|
{"vkGetImageSparseMemoryRequirements2KHR", &vkGetImageSparseMemoryRequirements2KHR},
|
|
|
|
{"vkGetImageSubresourceLayout", &vkGetImageSubresourceLayout},
|
2021-05-10 12:29:07 +02:00
|
|
|
{"vkGetImageViewAddressNVX", &vkGetImageViewAddressNVX},
|
|
|
|
{"vkGetImageViewHandleNVX", &vkGetImageViewHandleNVX},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkGetMemoryHostPointerPropertiesEXT", &vkGetMemoryHostPointerPropertiesEXT},
|
|
|
|
{"vkGetPerformanceParameterINTEL", &vkGetPerformanceParameterINTEL},
|
|
|
|
{"vkGetPipelineCacheData", &vkGetPipelineCacheData},
|
|
|
|
{"vkGetPipelineExecutableInternalRepresentationsKHR", &vkGetPipelineExecutableInternalRepresentationsKHR},
|
|
|
|
{"vkGetPipelineExecutablePropertiesKHR", &vkGetPipelineExecutablePropertiesKHR},
|
|
|
|
{"vkGetPipelineExecutableStatisticsKHR", &vkGetPipelineExecutableStatisticsKHR},
|
|
|
|
{"vkGetPrivateDataEXT", &vkGetPrivateDataEXT},
|
|
|
|
{"vkGetQueryPoolResults", &vkGetQueryPoolResults},
|
|
|
|
{"vkGetQueueCheckpointData2NV", &vkGetQueueCheckpointData2NV},
|
|
|
|
{"vkGetQueueCheckpointDataNV", &vkGetQueueCheckpointDataNV},
|
|
|
|
{"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", &vkGetRayTracingCaptureReplayShaderGroupHandlesKHR},
|
|
|
|
{"vkGetRayTracingShaderGroupHandlesKHR", &vkGetRayTracingShaderGroupHandlesKHR},
|
|
|
|
{"vkGetRayTracingShaderGroupHandlesNV", &vkGetRayTracingShaderGroupHandlesNV},
|
|
|
|
{"vkGetRayTracingShaderGroupStackSizeKHR", &vkGetRayTracingShaderGroupStackSizeKHR},
|
|
|
|
{"vkGetRenderAreaGranularity", &vkGetRenderAreaGranularity},
|
|
|
|
{"vkGetSemaphoreCounterValue", &vkGetSemaphoreCounterValue},
|
|
|
|
{"vkGetSemaphoreCounterValueKHR", &vkGetSemaphoreCounterValueKHR},
|
|
|
|
{"vkGetShaderInfoAMD", &vkGetShaderInfoAMD},
|
|
|
|
{"vkGetSwapchainImagesKHR", &vkGetSwapchainImagesKHR},
|
|
|
|
{"vkGetValidationCacheDataEXT", &vkGetValidationCacheDataEXT},
|
|
|
|
{"vkInitializePerformanceApiINTEL", &vkInitializePerformanceApiINTEL},
|
|
|
|
{"vkInvalidateMappedMemoryRanges", &vkInvalidateMappedMemoryRanges},
|
|
|
|
{"vkMapMemory", &vkMapMemory},
|
|
|
|
{"vkMergePipelineCaches", &vkMergePipelineCaches},
|
|
|
|
{"vkMergeValidationCachesEXT", &vkMergeValidationCachesEXT},
|
|
|
|
{"vkQueueBeginDebugUtilsLabelEXT", &vkQueueBeginDebugUtilsLabelEXT},
|
|
|
|
{"vkQueueBindSparse", &vkQueueBindSparse},
|
|
|
|
{"vkQueueEndDebugUtilsLabelEXT", &vkQueueEndDebugUtilsLabelEXT},
|
|
|
|
{"vkQueueInsertDebugUtilsLabelEXT", &vkQueueInsertDebugUtilsLabelEXT},
|
|
|
|
{"vkQueuePresentKHR", &vkQueuePresentKHR},
|
|
|
|
{"vkQueueSetPerformanceConfigurationINTEL", &vkQueueSetPerformanceConfigurationINTEL},
|
|
|
|
{"vkQueueSubmit", &vkQueueSubmit},
|
|
|
|
{"vkQueueSubmit2KHR", &vkQueueSubmit2KHR},
|
|
|
|
{"vkQueueWaitIdle", &vkQueueWaitIdle},
|
|
|
|
{"vkReleasePerformanceConfigurationINTEL", &vkReleasePerformanceConfigurationINTEL},
|
|
|
|
{"vkReleaseProfilingLockKHR", &vkReleaseProfilingLockKHR},
|
|
|
|
{"vkResetCommandBuffer", &vkResetCommandBuffer},
|
|
|
|
{"vkResetCommandPool", &vkResetCommandPool},
|
|
|
|
{"vkResetDescriptorPool", &vkResetDescriptorPool},
|
|
|
|
{"vkResetEvent", &vkResetEvent},
|
|
|
|
{"vkResetFences", &vkResetFences},
|
|
|
|
{"vkResetQueryPool", &vkResetQueryPool},
|
|
|
|
{"vkResetQueryPoolEXT", &vkResetQueryPoolEXT},
|
|
|
|
{"vkSetDebugUtilsObjectNameEXT", &vkSetDebugUtilsObjectNameEXT},
|
|
|
|
{"vkSetDebugUtilsObjectTagEXT", &vkSetDebugUtilsObjectTagEXT},
|
2021-09-07 21:39:18 +02:00
|
|
|
{"vkSetDeviceMemoryPriorityEXT", &vkSetDeviceMemoryPriorityEXT},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkSetEvent", &vkSetEvent},
|
|
|
|
{"vkSetPrivateDataEXT", &vkSetPrivateDataEXT},
|
|
|
|
{"vkSignalSemaphore", &vkSignalSemaphore},
|
|
|
|
{"vkSignalSemaphoreKHR", &vkSignalSemaphoreKHR},
|
|
|
|
{"vkTrimCommandPool", &vkTrimCommandPool},
|
|
|
|
{"vkTrimCommandPoolKHR", &vkTrimCommandPoolKHR},
|
|
|
|
{"vkUninitializePerformanceApiINTEL", &vkUninitializePerformanceApiINTEL},
|
|
|
|
{"vkUnmapMemory", &vkUnmapMemory},
|
|
|
|
{"vkUpdateDescriptorSetWithTemplate", &vkUpdateDescriptorSetWithTemplate},
|
|
|
|
{"vkUpdateDescriptorSetWithTemplateKHR", &vkUpdateDescriptorSetWithTemplateKHR},
|
|
|
|
{"vkUpdateDescriptorSets", &vkUpdateDescriptorSets},
|
|
|
|
{"vkWaitForFences", &vkWaitForFences},
|
2021-07-20 15:04:48 +02:00
|
|
|
{"vkWaitForPresentKHR", &vkWaitForPresentKHR},
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkWaitSemaphores", &vkWaitSemaphores},
|
|
|
|
{"vkWaitSemaphoresKHR", &vkWaitSemaphoresKHR},
|
|
|
|
{"vkWriteAccelerationStructuresPropertiesKHR", &vkWriteAccelerationStructuresPropertiesKHR},
|
2021-04-16 15:48:48 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct vulkan_func vk_phys_dev_dispatch_table[] =
|
|
|
|
{
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkCreateDevice", &vkCreateDevice},
|
|
|
|
{"vkEnumerateDeviceExtensionProperties", &vkEnumerateDeviceExtensionProperties},
|
|
|
|
{"vkEnumerateDeviceLayerProperties", &vkEnumerateDeviceLayerProperties},
|
|
|
|
{"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", &vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR},
|
|
|
|
{"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", &vkGetPhysicalDeviceCalibrateableTimeDomainsEXT},
|
|
|
|
{"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", &vkGetPhysicalDeviceCooperativeMatrixPropertiesNV},
|
|
|
|
{"vkGetPhysicalDeviceExternalBufferProperties", &vkGetPhysicalDeviceExternalBufferProperties},
|
|
|
|
{"vkGetPhysicalDeviceExternalBufferPropertiesKHR", &vkGetPhysicalDeviceExternalBufferPropertiesKHR},
|
|
|
|
{"vkGetPhysicalDeviceExternalFenceProperties", &vkGetPhysicalDeviceExternalFenceProperties},
|
|
|
|
{"vkGetPhysicalDeviceExternalFencePropertiesKHR", &vkGetPhysicalDeviceExternalFencePropertiesKHR},
|
|
|
|
{"vkGetPhysicalDeviceExternalSemaphoreProperties", &vkGetPhysicalDeviceExternalSemaphoreProperties},
|
|
|
|
{"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", &vkGetPhysicalDeviceExternalSemaphorePropertiesKHR},
|
|
|
|
{"vkGetPhysicalDeviceFeatures", &vkGetPhysicalDeviceFeatures},
|
|
|
|
{"vkGetPhysicalDeviceFeatures2", &vkGetPhysicalDeviceFeatures2},
|
|
|
|
{"vkGetPhysicalDeviceFeatures2KHR", &vkGetPhysicalDeviceFeatures2KHR},
|
|
|
|
{"vkGetPhysicalDeviceFormatProperties", &vkGetPhysicalDeviceFormatProperties},
|
|
|
|
{"vkGetPhysicalDeviceFormatProperties2", &vkGetPhysicalDeviceFormatProperties2},
|
|
|
|
{"vkGetPhysicalDeviceFormatProperties2KHR", &vkGetPhysicalDeviceFormatProperties2KHR},
|
|
|
|
{"vkGetPhysicalDeviceFragmentShadingRatesKHR", &vkGetPhysicalDeviceFragmentShadingRatesKHR},
|
|
|
|
{"vkGetPhysicalDeviceImageFormatProperties", &vkGetPhysicalDeviceImageFormatProperties},
|
|
|
|
{"vkGetPhysicalDeviceImageFormatProperties2", &vkGetPhysicalDeviceImageFormatProperties2},
|
|
|
|
{"vkGetPhysicalDeviceImageFormatProperties2KHR", &vkGetPhysicalDeviceImageFormatProperties2KHR},
|
|
|
|
{"vkGetPhysicalDeviceMemoryProperties", &vkGetPhysicalDeviceMemoryProperties},
|
|
|
|
{"vkGetPhysicalDeviceMemoryProperties2", &vkGetPhysicalDeviceMemoryProperties2},
|
|
|
|
{"vkGetPhysicalDeviceMemoryProperties2KHR", &vkGetPhysicalDeviceMemoryProperties2KHR},
|
|
|
|
{"vkGetPhysicalDeviceMultisamplePropertiesEXT", &vkGetPhysicalDeviceMultisamplePropertiesEXT},
|
|
|
|
{"vkGetPhysicalDevicePresentRectanglesKHR", &vkGetPhysicalDevicePresentRectanglesKHR},
|
|
|
|
{"vkGetPhysicalDeviceProperties", &vkGetPhysicalDeviceProperties},
|
|
|
|
{"vkGetPhysicalDeviceProperties2", &vkGetPhysicalDeviceProperties2},
|
|
|
|
{"vkGetPhysicalDeviceProperties2KHR", &vkGetPhysicalDeviceProperties2KHR},
|
|
|
|
{"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", &vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR},
|
|
|
|
{"vkGetPhysicalDeviceQueueFamilyProperties", &vkGetPhysicalDeviceQueueFamilyProperties},
|
|
|
|
{"vkGetPhysicalDeviceQueueFamilyProperties2", &vkGetPhysicalDeviceQueueFamilyProperties2},
|
|
|
|
{"vkGetPhysicalDeviceQueueFamilyProperties2KHR", &vkGetPhysicalDeviceQueueFamilyProperties2KHR},
|
|
|
|
{"vkGetPhysicalDeviceSparseImageFormatProperties", &vkGetPhysicalDeviceSparseImageFormatProperties},
|
|
|
|
{"vkGetPhysicalDeviceSparseImageFormatProperties2", &vkGetPhysicalDeviceSparseImageFormatProperties2},
|
|
|
|
{"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", &vkGetPhysicalDeviceSparseImageFormatProperties2KHR},
|
|
|
|
{"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", &vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV},
|
|
|
|
{"vkGetPhysicalDeviceSurfaceCapabilities2KHR", &vkGetPhysicalDeviceSurfaceCapabilities2KHR},
|
|
|
|
{"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", &vkGetPhysicalDeviceSurfaceCapabilitiesKHR},
|
|
|
|
{"vkGetPhysicalDeviceSurfaceFormats2KHR", &vkGetPhysicalDeviceSurfaceFormats2KHR},
|
|
|
|
{"vkGetPhysicalDeviceSurfaceFormatsKHR", &vkGetPhysicalDeviceSurfaceFormatsKHR},
|
|
|
|
{"vkGetPhysicalDeviceSurfacePresentModesKHR", &vkGetPhysicalDeviceSurfacePresentModesKHR},
|
|
|
|
{"vkGetPhysicalDeviceSurfaceSupportKHR", &vkGetPhysicalDeviceSurfaceSupportKHR},
|
|
|
|
{"vkGetPhysicalDeviceToolPropertiesEXT", &vkGetPhysicalDeviceToolPropertiesEXT},
|
|
|
|
{"vkGetPhysicalDeviceWin32PresentationSupportKHR", &vkGetPhysicalDeviceWin32PresentationSupportKHR},
|
2021-04-16 15:48:48 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct vulkan_func vk_instance_dispatch_table[] =
|
|
|
|
{
|
2021-04-29 14:38:50 +02:00
|
|
|
{"vkCreateDebugReportCallbackEXT", &vkCreateDebugReportCallbackEXT},
|
|
|
|
{"vkCreateDebugUtilsMessengerEXT", &vkCreateDebugUtilsMessengerEXT},
|
|
|
|
{"vkCreateWin32SurfaceKHR", &vkCreateWin32SurfaceKHR},
|
|
|
|
{"vkDebugReportMessageEXT", &vkDebugReportMessageEXT},
|
|
|
|
{"vkDestroyDebugReportCallbackEXT", &vkDestroyDebugReportCallbackEXT},
|
|
|
|
{"vkDestroyDebugUtilsMessengerEXT", &vkDestroyDebugUtilsMessengerEXT},
|
|
|
|
{"vkDestroyInstance", &vkDestroyInstance},
|
|
|
|
{"vkDestroySurfaceKHR", &vkDestroySurfaceKHR},
|
|
|
|
{"vkEnumeratePhysicalDeviceGroups", &vkEnumeratePhysicalDeviceGroups},
|
|
|
|
{"vkEnumeratePhysicalDeviceGroupsKHR", &vkEnumeratePhysicalDeviceGroupsKHR},
|
|
|
|
{"vkEnumeratePhysicalDevices", &vkEnumeratePhysicalDevices},
|
|
|
|
{"vkSubmitDebugUtilsMessageEXT", &vkSubmitDebugUtilsMessageEXT},
|
2021-04-16 15:48:48 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
void *wine_vk_get_device_proc_addr(const char *name)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(vk_device_dispatch_table); i++)
|
|
|
|
{
|
|
|
|
if (strcmp(vk_device_dispatch_table[i].name, name) == 0)
|
|
|
|
{
|
|
|
|
TRACE("Found name=%s in device table\n", debugstr_a(name));
|
|
|
|
return vk_device_dispatch_table[i].func;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *wine_vk_get_phys_dev_proc_addr(const char *name)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(vk_phys_dev_dispatch_table); i++)
|
|
|
|
{
|
|
|
|
if (strcmp(vk_phys_dev_dispatch_table[i].name, name) == 0)
|
|
|
|
{
|
|
|
|
TRACE("Found name=%s in physical device table\n", debugstr_a(name));
|
|
|
|
return vk_phys_dev_dispatch_table[i].func;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *wine_vk_get_instance_proc_addr(const char *name)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(vk_instance_dispatch_table); i++)
|
|
|
|
{
|
|
|
|
if (strcmp(vk_instance_dispatch_table[i].name, name) == 0)
|
|
|
|
{
|
|
|
|
TRACE("Found name=%s in instance table\n", debugstr_a(name));
|
|
|
|
return vk_instance_dispatch_table[i].func;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|