system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-06 08:54:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

winevulkan: Update to VK spec version 1.3.258.

Browse source 
This does not enable VK_NV_device_generated_commands_compute because
the extension will likely see an API breaking naming fix.
This commit is contained in:
Georg Lehmann 2023-07-21 13:19:31 +02:00 committed by Alexandre Julliard
parent 61ad9174e2
commit eb5be00eb0
7 changed files with 1018 additions and 25 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
dlls/winevulkan/loader_thunks.c
View file

@ -2490,6 +2490,28 @@ VkResult WINAPI vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferr
return params.result;
}
VkResult WINAPI vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfoEXT *pCopyImageToImageInfo)
{
struct vkCopyImageToImageEXT_params params;
NTSTATUS status;
params.device = device;
params.pCopyImageToImageInfo = pCopyImageToImageInfo;
status = UNIX_CALL(vkCopyImageToImageEXT, &params);
assert(!status && "vkCopyImageToImageEXT");
return params.result;
}
VkResult WINAPI vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfoEXT *pCopyImageToMemoryInfo)
{
struct vkCopyImageToMemoryEXT_params params;
NTSTATUS status;
params.device = device;
params.pCopyImageToMemoryInfo = pCopyImageToMemoryInfo;
status = UNIX_CALL(vkCopyImageToMemoryEXT, &params);
assert(!status && "vkCopyImageToMemoryEXT");
return params.result;
}
VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
{
struct vkCopyMemoryToAccelerationStructureKHR_params params;
@ -2502,6 +2524,17 @@ VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferr
return params.result;
}
VkResult WINAPI vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfoEXT *pCopyMemoryToImageInfo)
{
struct vkCopyMemoryToImageEXT_params params;
NTSTATUS status;
params.device = device;
params.pCopyMemoryToImageInfo = pCopyMemoryToImageInfo;
status = UNIX_CALL(vkCopyMemoryToImageEXT, &params);
assert(!status && "vkCopyMemoryToImageEXT");
return params.result;
}
VkResult WINAPI vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
{
struct vkCopyMemoryToMicromapEXT_params params;
@ -4419,6 +4452,18 @@ VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice
return params.result;
}
VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties)
{
struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params params;
NTSTATUS status;
params.physicalDevice = physicalDevice;
params.pPropertyCount = pPropertyCount;
params.pProperties = pProperties;
status = UNIX_CALL(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, &params);
assert(!status && "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR");
return params.result;
}
VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
{
struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params params;
@ -5626,6 +5671,18 @@ void WINAPI vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessag
assert(!status && "vkSubmitDebugUtilsMessageEXT");
}
VkResult WINAPI vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT *pTransitions)
{
struct vkTransitionImageLayoutEXT_params params;
NTSTATUS status;
params.device = device;
params.transitionCount = transitionCount;
params.pTransitions = pTransitions;
status = UNIX_CALL(vkTransitionImageLayoutEXT, &params);
assert(!status && "vkTransitionImageLayoutEXT");
return params.result;
}
void WINAPI vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
{
struct vkTrimCommandPool_params params;
@ -6049,7 +6106,10 @@ static const struct vulkan_func vk_device_dispatch_table[] =
{"vkCompileDeferredNV", vkCompileDeferredNV},
{"vkCopyAccelerationStructureKHR", vkCopyAccelerationStructureKHR},
{"vkCopyAccelerationStructureToMemoryKHR", vkCopyAccelerationStructureToMemoryKHR},
{"vkCopyImageToImageEXT", vkCopyImageToImageEXT},
{"vkCopyImageToMemoryEXT", vkCopyImageToMemoryEXT},
{"vkCopyMemoryToAccelerationStructureKHR", vkCopyMemoryToAccelerationStructureKHR},
{"vkCopyMemoryToImageEXT", vkCopyMemoryToImageEXT},
{"vkCopyMemoryToMicromapEXT", vkCopyMemoryToMicromapEXT},
{"vkCopyMicromapEXT", vkCopyMicromapEXT},
{"vkCopyMicromapToMemoryEXT", vkCopyMicromapToMemoryEXT},
@ -6261,6 +6321,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
{"vkSetPrivateDataEXT", vkSetPrivateDataEXT},
{"vkSignalSemaphore", vkSignalSemaphore},
{"vkSignalSemaphoreKHR", vkSignalSemaphoreKHR},
{"vkTransitionImageLayoutEXT", vkTransitionImageLayoutEXT},
{"vkTrimCommandPool", vkTrimCommandPool},
{"vkTrimCommandPoolKHR", vkTrimCommandPoolKHR},
{"vkUninitializePerformanceApiINTEL", vkUninitializePerformanceApiINTEL},
@ -6284,6 +6345,7 @@ static const struct vulkan_func vk_phys_dev_dispatch_table[] =
{"vkEnumerateDeviceLayerProperties", vkEnumerateDeviceLayerProperties},
{"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR},
{"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", vkGetPhysicalDeviceCalibrateableTimeDomainsEXT},
{"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR},
{"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", vkGetPhysicalDeviceCooperativeMatrixPropertiesNV},
{"vkGetPhysicalDeviceExternalBufferProperties", vkGetPhysicalDeviceExternalBufferProperties},
{"vkGetPhysicalDeviceExternalBufferPropertiesKHR", vkGetPhysicalDeviceExternalBufferPropertiesKHR},

42
dlls/winevulkan/loader_thunks.h
View file

@ -270,7 +270,10 @@ enum unix_call
unix_vkCompileDeferredNV,
unix_vkCopyAccelerationStructureKHR,
unix_vkCopyAccelerationStructureToMemoryKHR,
unix_vkCopyImageToImageEXT,
unix_vkCopyImageToMemoryEXT,
unix_vkCopyMemoryToAccelerationStructureKHR,
unix_vkCopyMemoryToImageEXT,
unix_vkCopyMemoryToMicromapEXT,
unix_vkCopyMicromapEXT,
unix_vkCopyMicromapToMemoryEXT,
@ -441,6 +444,7 @@ enum unix_call
unix_vkGetMicromapBuildSizesEXT,
unix_vkGetPerformanceParameterINTEL,
unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR,
unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
unix_vkGetPhysicalDeviceExternalBufferProperties,
unix_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
@ -544,6 +548,7 @@ enum unix_call
unix_vkSignalSemaphore,
unix_vkSignalSemaphoreKHR,
unix_vkSubmitDebugUtilsMessageEXT,
unix_vkTransitionImageLayoutEXT,
unix_vkTrimCommandPool,
unix_vkTrimCommandPoolKHR,
unix_vkUninitializePerformanceApiINTEL,
@ -2496,6 +2501,20 @@ struct vkCopyAccelerationStructureToMemoryKHR_params
VkResult result;
};
struct vkCopyImageToImageEXT_params
{
VkDevice device;
const VkCopyImageToImageInfoEXT *pCopyImageToImageInfo;
VkResult result;
};
struct vkCopyImageToMemoryEXT_params
{
VkDevice device;
const VkCopyImageToMemoryInfoEXT *pCopyImageToMemoryInfo;
VkResult result;
};
struct vkCopyMemoryToAccelerationStructureKHR_params
{
VkDevice device;
@ -2504,6 +2523,13 @@ struct vkCopyMemoryToAccelerationStructureKHR_params
VkResult result;
};
struct vkCopyMemoryToImageEXT_params
{
VkDevice device;
const VkCopyMemoryToImageInfoEXT *pCopyMemoryToImageInfo;
VkResult result;
};
struct vkCopyMemoryToMicromapEXT_params
{
VkDevice device;
@ -3849,6 +3875,14 @@ struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params
VkResult result;
};
struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params
{
VkPhysicalDevice physicalDevice;
uint32_t *pPropertyCount;
VkCooperativeMatrixPropertiesKHR *pProperties;
VkResult result;
};
struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params
{
VkPhysicalDevice physicalDevice;
@ -4664,6 +4698,14 @@ struct vkSubmitDebugUtilsMessageEXT_params
const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData;
};
struct vkTransitionImageLayoutEXT_params
{
VkDevice device;
uint32_t transitionCount;
const VkHostImageLayoutTransitionInfoEXT *pTransitions;
VkResult result;
};
struct vkTrimCommandPool_params
{
VkDevice device;

5
dlls/winevulkan/make_vulkan
View file

@ -65,7 +65,7 @@ from enum import Enum
LOGGER = logging.Logger("vulkan")
LOGGER.addHandler(logging.StreamHandler())
VK_XML_VERSION = "1.3.254"
VK_XML_VERSION = "1.3.258"
WINE_VK_VERSION = (1, 3)
# Filenames to create.
@ -123,6 +123,9 @@ UNSUPPORTED_EXTENSIONS = [
# Deprecated extensions
"VK_NV_external_memory_capabilities",
"VK_NV_external_memory_win32",
# Likely broken: https://github.com/KhronosGroup/Vulkan-Docs/issues/2171
"VK_NV_device_generated_commands_compute",
]
# Either internal extensions which aren't present on the win32 platform which

689
dlls/winevulkan/vulkan_thunks.c
View file

@ -1160,6 +1160,65 @@ typedef struct VkStridedDeviceAddressRegionKHR32
VkDeviceSize DECLSPEC_ALIGN(8) size;
} VkStridedDeviceAddressRegionKHR32;
typedef struct VkCopyImageToImageInfoEXT32
{
VkStructureType sType;
PTR32 pNext;
VkHostImageCopyFlagsEXT flags;
VkImage DECLSPEC_ALIGN(8) srcImage;
VkImageLayout srcImageLayout;
VkImage DECLSPEC_ALIGN(8) dstImage;
VkImageLayout dstImageLayout;
uint32_t regionCount;
PTR32 pRegions;
} VkCopyImageToImageInfoEXT32;
typedef struct VkImageToMemoryCopyEXT32
{
VkStructureType sType;
PTR32 pNext;
PTR32 pHostPointer;
uint32_t memoryRowLength;
uint32_t memoryImageHeight;
VkImageSubresourceLayers imageSubresource;
VkOffset3D imageOffset;
VkExtent3D imageExtent;
} VkImageToMemoryCopyEXT32;
typedef struct VkCopyImageToMemoryInfoEXT32
{
VkStructureType sType;
PTR32 pNext;
VkHostImageCopyFlagsEXT flags;
VkImage DECLSPEC_ALIGN(8) srcImage;
VkImageLayout srcImageLayout;
uint32_t regionCount;
PTR32 pRegions;
} VkCopyImageToMemoryInfoEXT32;
typedef struct VkMemoryToImageCopyEXT32
{
VkStructureType sType;
PTR32 pNext;
PTR32 pHostPointer;
uint32_t memoryRowLength;
uint32_t memoryImageHeight;
VkImageSubresourceLayers imageSubresource;
VkOffset3D imageOffset;
VkExtent3D imageExtent;
} VkMemoryToImageCopyEXT32;
typedef struct VkCopyMemoryToImageInfoEXT32
{
VkStructureType sType;
PTR32 pNext;
VkHostImageCopyFlagsEXT flags;
VkImage DECLSPEC_ALIGN(8) dstImage;
VkImageLayout dstImageLayout;
uint32_t regionCount;
PTR32 pRegions;
} VkCopyMemoryToImageInfoEXT32;
typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT32
{
VkStructureType sType;
@ -2543,6 +2602,13 @@ typedef struct VkPhysicalDeviceSynchronization2Features32
} VkPhysicalDeviceSynchronization2Features32;
typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32;
typedef struct VkPhysicalDeviceHostImageCopyFeaturesEXT32
{
VkStructureType sType;
PTR32 pNext;
VkBool32 hostImageCopy;
} VkPhysicalDeviceHostImageCopyFeaturesEXT32;
typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32
{
VkStructureType sType;
@ -2881,6 +2947,14 @@ typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT32
VkBool32 shaderTileImageStencilReadAccess;
} VkPhysicalDeviceShaderTileImageFeaturesEXT32;
typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR32
{
VkStructureType sType;
PTR32 pNext;
VkBool32 cooperativeMatrix;
VkBool32 cooperativeMatrixRobustBufferAccess;
} VkPhysicalDeviceCooperativeMatrixFeaturesKHR32;
typedef struct VkDeviceCreateInfo32
{
VkStructureType sType;
@ -4442,6 +4516,13 @@ typedef struct VkImageSubresource2EXT32
VkImageSubresource imageSubresource;
} VkImageSubresource2EXT32;
typedef struct VkSubresourceHostMemcpySizeEXT32
{
VkStructureType sType;
PTR32 pNext;
VkDeviceSize DECLSPEC_ALIGN(8) size;
} VkSubresourceHostMemcpySizeEXT32;
typedef struct VkImageCompressionPropertiesEXT32
{
VkStructureType sType;
@ -4512,6 +4593,21 @@ typedef struct VkPerformanceValueINTEL32
VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data;
} VkPerformanceValueINTEL32;
typedef struct VkCooperativeMatrixPropertiesKHR32
{
VkStructureType sType;
PTR32 pNext;
uint32_t MSize;
uint32_t NSize;
uint32_t KSize;
VkComponentTypeKHR AType;
VkComponentTypeKHR BType;
VkComponentTypeKHR CType;
VkComponentTypeKHR ResultType;
VkBool32 saturatingAccumulation;
VkScopeKHR scope;
} VkCooperativeMatrixPropertiesKHR32;
typedef struct VkCooperativeMatrixPropertiesNV32
{
VkStructureType sType;
@ -4680,6 +4776,14 @@ typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32
VkBool32 filterCubicMinmax;
} VkFilterCubicImageViewImageFormatPropertiesEXT32;
typedef struct VkHostImageCopyDevicePerformanceQueryEXT32
{
VkStructureType sType;
PTR32 pNext;
VkBool32 optimalDeviceAccess;
VkBool32 identicalMemoryLayout;
} VkHostImageCopyDevicePerformanceQueryEXT32;
typedef struct VkImageFormatProperties232
{
VkStructureType sType;
@ -5560,6 +5664,18 @@ typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32
VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;
} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32;
typedef struct VkPhysicalDeviceHostImageCopyPropertiesEXT32
{
VkStructureType sType;
PTR32 pNext;
uint32_t copySrcLayoutCount;
PTR32 pCopySrcLayouts;
uint32_t copyDstLayoutCount;
PTR32 pCopyDstLayouts;
uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
VkBool32 identicalMemoryTypeRequirements;
} VkPhysicalDeviceHostImageCopyPropertiesEXT32;
typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32
{
VkStructureType sType;
@ -5760,6 +5876,13 @@ typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT32
VkBool32 shaderTileImageReadFromHelperInvocation;
} VkPhysicalDeviceShaderTileImagePropertiesEXT32;
typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR32
{
VkStructureType sType;
PTR32 pNext;
VkShaderStageFlags cooperativeMatrixSupportedStages;
} VkPhysicalDeviceCooperativeMatrixPropertiesKHR32;
typedef struct VkPhysicalDeviceProperties232
{
VkStructureType sType;
@ -6277,6 +6400,16 @@ typedef struct VkDebugUtilsMessengerCallbackDataEXT32
PTR32 pObjects;
} VkDebugUtilsMessengerCallbackDataEXT32;
typedef struct VkHostImageLayoutTransitionInfoEXT32
{
VkStructureType sType;
PTR32 pNext;
VkImage DECLSPEC_ALIGN(8) image;
VkImageLayout oldLayout;
VkImageLayout newLayout;
VkImageSubresourceRange subresourceRange;
} VkHostImageLayoutTransitionInfoEXT32;
typedef struct VkMemoryUnmapInfoKHR32
{
VkStructureType sType;
@ -8950,6 +9083,117 @@ static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_ho
return out;
}
static inline void convert_VkCopyImageToImageInfoEXT_win32_to_host(struct conversion_context *ctx, const VkCopyImageToImageInfoEXT32 *in, VkCopyImageToImageInfoEXT *out)
{
if (!in) return;
out->sType = in->sType;
out->pNext = NULL;
out->flags = in->flags;
out->srcImage = in->srcImage;
out->srcImageLayout = in->srcImageLayout;
out->dstImage = in->dstImage;
out->dstImageLayout = in->dstImageLayout;
out->regionCount = in->regionCount;
out->pRegions = convert_VkImageCopy2_array_win32_to_host(ctx, (const VkImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
if (in->pNext)
FIXME("Unexpected pNext\n");
}
static inline void convert_VkImageToMemoryCopyEXT_win32_to_host(const VkImageToMemoryCopyEXT32 *in, VkImageToMemoryCopyEXT *out)
{
if (!in) return;
out->sType = in->sType;
out->pNext = NULL;
out->pHostPointer = (void *)UlongToPtr(in->pHostPointer);
out->memoryRowLength = in->memoryRowLength;
out->memoryImageHeight = in->memoryImageHeight;
out->imageSubresource = in->imageSubresource;
out->imageOffset = in->imageOffset;
out->imageExtent = in->imageExtent;
if (in->pNext)
FIXME("Unexpected pNext\n");
}
static inline const VkImageToMemoryCopyEXT *convert_VkImageToMemoryCopyEXT_array_win32_to_host(struct conversion_context *ctx, const VkImageToMemoryCopyEXT32 *in, uint32_t count)
{
VkImageToMemoryCopyEXT *out;
unsigned int i;
if (!in || !count) return NULL;
out = conversion_context_alloc(ctx, count * sizeof(*out));
for (i = 0; i < count; i++)
{
convert_VkImageToMemoryCopyEXT_win32_to_host(&in[i], &out[i]);
}
return out;
}
static inline void convert_VkCopyImageToMemoryInfoEXT_win32_to_host(struct conversion_context *ctx, const VkCopyImageToMemoryInfoEXT32 *in, VkCopyImageToMemoryInfoEXT *out)
{
if (!in) return;
out->sType = in->sType;
out->pNext = NULL;
out->flags = in->flags;
out->srcImage = in->srcImage;
out->srcImageLayout = in->srcImageLayout;
out->regionCount = in->regionCount;
out->pRegions = convert_VkImageToMemoryCopyEXT_array_win32_to_host(ctx, (const VkImageToMemoryCopyEXT32 *)UlongToPtr(in->pRegions), in->regionCount);
if (in->pNext)
FIXME("Unexpected pNext\n");
}
static inline void convert_VkMemoryToImageCopyEXT_win32_to_host(const VkMemoryToImageCopyEXT32 *in, VkMemoryToImageCopyEXT *out)
{
if (!in) return;
out->sType = in->sType;
out->pNext = NULL;
out->pHostPointer = (const void *)UlongToPtr(in->pHostPointer);
out->memoryRowLength = in->memoryRowLength;
out->memoryImageHeight = in->memoryImageHeight;
out->imageSubresource = in->imageSubresource;
out->imageOffset = in->imageOffset;
out->imageExtent = in->imageExtent;
if (in->pNext)
FIXME("Unexpected pNext\n");
}
static inline const VkMemoryToImageCopyEXT *convert_VkMemoryToImageCopyEXT_array_win32_to_host(struct conversion_context *ctx, const VkMemoryToImageCopyEXT32 *in, uint32_t count)
{
VkMemoryToImageCopyEXT *out;
unsigned int i;
if (!in || !count) return NULL;
out = conversion_context_alloc(ctx, count * sizeof(*out));
for (i = 0; i < count; i++)
{
convert_VkMemoryToImageCopyEXT_win32_to_host(&in[i], &out[i]);
}
return out;
}
static inline void convert_VkCopyMemoryToImageInfoEXT_win32_to_host(struct conversion_context *ctx, const VkCopyMemoryToImageInfoEXT32 *in, VkCopyMemoryToImageInfoEXT *out)
{
if (!in) return;
out->sType = in->sType;
out->pNext = NULL;
out->flags = in->flags;
out->dstImage = in->dstImage;
out->dstImageLayout = in->dstImageLayout;
out->regionCount = in->regionCount;
out->pRegions = convert_VkMemoryToImageCopyEXT_array_win32_to_host(ctx, (const VkMemoryToImageCopyEXT32 *)UlongToPtr(in->pRegions), in->regionCount);
if (in->pNext)
FIXME("Unexpected pNext\n");
}
static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out)
{
const VkBaseInStructure32 *in_header;
@ -11394,6 +11638,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
{
VkPhysicalDeviceHostImageCopyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
const VkPhysicalDeviceHostImageCopyFeaturesEXT *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT;
out_ext->pNext = NULL;
out_ext->hostImageCopy = in_ext->hostImageCopy;
out_header->pNext = (void *)out_ext;
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
{
VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@ -11908,6 +12163,18 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
{
VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
out_ext->pNext = NULL;
out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
out_header->pNext = (void *)out_ext;
out_header = (void *)out_ext;
break;
}
default:
FIXME("Unhandled sType %u.\n", in_header->sType);
break;
@ -13371,6 +13638,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
{
VkPhysicalDeviceHostImageCopyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT;
out_ext->pNext = NULL;
out_ext->hostImageCopy = in_ext->hostImageCopy;
out_header->pNext = (void *)out_ext;
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
{
VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@ -13885,6 +14163,18 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
{
VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
out_ext->pNext = NULL;
out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
out_header->pNext = (void *)out_ext;
out_header = (void *)out_ext;
break;
}
default:
FIXME("Unhandled sType %u.\n", in_header->sType);
break;
@ -18236,6 +18526,15 @@ static inline void convert_VkSubresourceLayout2EXT_win32_to_host(struct conversi
{
switch (in_header->sType)
{
case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
{
VkSubresourceHostMemcpySizeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT;
out_ext->pNext = NULL;
out_header->pNext = (void *)out_ext;
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
{
VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@ -18265,6 +18564,15 @@ static inline void convert_VkSubresourceLayout2EXT_host_to_win32(const VkSubreso
{
switch (in_header->sType)
{
case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
{
VkSubresourceHostMemcpySizeEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT);
const VkSubresourceHostMemcpySizeEXT *in_ext = (const VkSubresourceHostMemcpySizeEXT *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT;
out_ext->size = in_ext->size;
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
{
VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
@ -18400,6 +18708,68 @@ static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerform
convert_VkPerformanceValueDataINTEL_host_to_win32(&in->data, &out->data, in->type);
}
static inline void convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(const VkCooperativeMatrixPropertiesKHR32 *in, VkCooperativeMatrixPropertiesKHR *out)
{
if (!in) return;
out->sType = in->sType;
out->pNext = NULL;
out->MSize = in->MSize;
out->NSize = in->NSize;
out->KSize = in->KSize;
out->AType = in->AType;
out->BType = in->BType;
out->CType = in->CType;
out->ResultType = in->ResultType;
out->saturatingAccumulation = in->saturatingAccumulation;
out->scope = in->scope;
if (in->pNext)
FIXME("Unexpected pNext\n");
}
static inline void convert_VkCooperativeMatrixPropertiesKHR_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out)
{
if (!in) return;
out->MSize = in->MSize;
out->NSize = in->NSize;
out->KSize = in->KSize;
out->AType = in->AType;
out->BType = in->BType;
out->CType = in->CType;
out->ResultType = in->ResultType;
out->saturatingAccumulation = in->saturatingAccumulation;
out->scope = in->scope;
}
static inline VkCooperativeMatrixPropertiesKHR *convert_VkCooperativeMatrixPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesKHR32 *in, uint32_t count)
{
VkCooperativeMatrixPropertiesKHR *out;
unsigned int i;
if (!in || !count) return NULL;
out = conversion_context_alloc(ctx, count * sizeof(*out));
for (i = 0; i < count; i++)
{
convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(&in[i], &out[i]);
}
return out;
}
static inline void convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out, uint32_t count)
{
unsigned int i;
if (!in) return;
for (i = 0; i < count; i++)
{
convert_VkCooperativeMatrixPropertiesKHR_host_to_win32(&in[i], &out[i]);
}
}
static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out)
{
if (!in) return;
@ -19944,6 +20314,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
{
VkPhysicalDeviceHostImageCopyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT;
out_ext->pNext = NULL;
out_ext->hostImageCopy = in_ext->hostImageCopy;
out_header->pNext = (void *)out_ext;
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
{
VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@ -20458,6 +20839,18 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
{
VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
out_ext->pNext = NULL;
out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
out_header->pNext = (void *)out_ext;
out_header = (void *)out_ext;
break;
}
default:
FIXME("Unhandled sType %u.\n", in_header->sType);
break;
@ -21632,6 +22025,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
{
VkPhysicalDeviceHostImageCopyFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT);
const VkPhysicalDeviceHostImageCopyFeaturesEXT *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT;
out_ext->hostImageCopy = in_ext->hostImageCopy;
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
{
VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
@ -22056,6 +22458,16 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
{
VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR);
const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
out_header = (void *)out_ext;
break;
}
default:
break;
}
@ -22342,6 +22754,15 @@ static inline void convert_VkImageFormatProperties2_win32_to_host(struct convers
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
{
VkHostImageCopyDevicePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
out_ext->sType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT;
out_ext->pNext = NULL;
out_header->pNext = (void *)out_ext;
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
{
VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@ -22408,6 +22829,16 @@ static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageF
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
{
VkHostImageCopyDevicePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT);
const VkHostImageCopyDevicePerformanceQueryEXT *in_ext = (const VkHostImageCopyDevicePerformanceQueryEXT *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT;
out_ext->optimalDeviceAccess = in_ext->optimalDeviceAccess;
out_ext->identicalMemoryLayout = in_ext->identicalMemoryLayout;
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
{
VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
@ -23217,6 +23648,22 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
{
VkPhysicalDeviceHostImageCopyPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
const VkPhysicalDeviceHostImageCopyPropertiesEXT32 *in_ext = (const VkPhysicalDeviceHostImageCopyPropertiesEXT32 *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT;
out_ext->pNext = NULL;
out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount;
out_ext->pCopySrcLayouts = (VkImageLayout *)UlongToPtr(in_ext->pCopySrcLayouts);
out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount;
out_ext->pCopyDstLayouts = (VkImageLayout *)UlongToPtr(in_ext->pCopyDstLayouts);
memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements;
out_header->pNext = (void *)out_ext;
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
{
VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@ -23364,6 +23811,15 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
{
VkPhysicalDeviceCooperativeMatrixPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
out_ext->pNext = NULL;
out_header->pNext = (void *)out_ext;
out_header = (void *)out_ext;
break;
}
default:
FIXME("Unhandled sType %u.\n", in_header->sType);
break;
@ -24183,6 +24639,20 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
{
VkPhysicalDeviceHostImageCopyPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT);
const VkPhysicalDeviceHostImageCopyPropertiesEXT *in_ext = (const VkPhysicalDeviceHostImageCopyPropertiesEXT *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT;
out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount;
out_ext->pCopySrcLayouts = PtrToUlong(in_ext->pCopySrcLayouts);
out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount;
out_ext->pCopyDstLayouts = PtrToUlong(in_ext->pCopyDstLayouts);
memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements;
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
{
VkPhysicalDeviceProvokingVertexPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
@ -24414,6 +24884,15 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy
out_header = (void *)out_ext;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
{
VkPhysicalDeviceCooperativeMatrixPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR);
const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *)in_header;
out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
out_header = (void *)out_ext;
break;
}
default:
break;
}
@ -26369,6 +26848,36 @@ static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(st
}
}
static inline void convert_VkHostImageLayoutTransitionInfoEXT_win32_to_host(const VkHostImageLayoutTransitionInfoEXT32 *in, VkHostImageLayoutTransitionInfoEXT *out)
{
if (!in) return;
out->sType = in->sType;
out->pNext = NULL;
out->image = in->image;
out->oldLayout = in->oldLayout;
out->newLayout = in->newLayout;
out->subresourceRange = in->subresourceRange;
if (in->pNext)
FIXME("Unexpected pNext\n");
}
static inline const VkHostImageLayoutTransitionInfoEXT *convert_VkHostImageLayoutTransitionInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkHostImageLayoutTransitionInfoEXT32 *in, uint32_t count)
{
VkHostImageLayoutTransitionInfoEXT *out;
unsigned int i;
if (!in || !count) return NULL;
out = conversion_context_alloc(ctx, count * sizeof(*out));
for (i = 0; i < count; i++)
{
convert_VkHostImageLayoutTransitionInfoEXT_win32_to_host(&in[i], &out[i]);
}
return out;
}
static inline void convert_VkMemoryUnmapInfoKHR_win32_to_unwrapped_host(const VkMemoryUnmapInfoKHR32 *in, VkMemoryUnmapInfoKHR *out)
{
if (!in) return;
@ -32515,6 +33024,72 @@ static NTSTATUS thunk32_vkCopyAccelerationStructureToMemoryKHR(void *args)
return STATUS_SUCCESS;
}
#ifdef _WIN64
static NTSTATUS thunk64_vkCopyImageToImageEXT(void *args)
{
struct vkCopyImageToImageEXT_params *params = args;
TRACE("%p, %p\n", params->device, params->pCopyImageToImageInfo);
params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyImageToImageEXT(wine_device_from_handle(params->device)->device, params->pCopyImageToImageInfo);
return STATUS_SUCCESS;
}
#endif /* _WIN64 */
static NTSTATUS thunk32_vkCopyImageToImageEXT(void *args)
{
struct
{
PTR32 device;
PTR32 pCopyImageToImageInfo;
VkResult result;
} *params = args;
VkCopyImageToImageInfoEXT pCopyImageToImageInfo_host;
struct conversion_context local_ctx;
struct conversion_context *ctx = &local_ctx;
TRACE("%#x, %#x\n", params->device, params->pCopyImageToImageInfo);
init_conversion_context(ctx);
convert_VkCopyImageToImageInfoEXT_win32_to_host(ctx, (const VkCopyImageToImageInfoEXT32 *)UlongToPtr(params->pCopyImageToImageInfo), &pCopyImageToImageInfo_host);
params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyImageToImageEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCopyImageToImageInfo_host);
free_conversion_context(ctx);
return STATUS_SUCCESS;
}
#ifdef _WIN64
static NTSTATUS thunk64_vkCopyImageToMemoryEXT(void *args)
{
struct vkCopyImageToMemoryEXT_params *params = args;
TRACE("%p, %p\n", params->device, params->pCopyImageToMemoryInfo);
params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyImageToMemoryEXT(wine_device_from_handle(params->device)->device, params->pCopyImageToMemoryInfo);
return STATUS_SUCCESS;
}
#endif /* _WIN64 */
static NTSTATUS thunk32_vkCopyImageToMemoryEXT(void *args)
{
struct
{
PTR32 device;
PTR32 pCopyImageToMemoryInfo;
VkResult result;
} *params = args;
VkCopyImageToMemoryInfoEXT pCopyImageToMemoryInfo_host;
struct conversion_context local_ctx;
struct conversion_context *ctx = &local_ctx;
TRACE("%#x, %#x\n", params->device, params->pCopyImageToMemoryInfo);
init_conversion_context(ctx);
convert_VkCopyImageToMemoryInfoEXT_win32_to_host(ctx, (const VkCopyImageToMemoryInfoEXT32 *)UlongToPtr(params->pCopyImageToMemoryInfo), &pCopyImageToMemoryInfo_host);
params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyImageToMemoryEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCopyImageToMemoryInfo_host);
free_conversion_context(ctx);
return STATUS_SUCCESS;
}
#ifdef _WIN64
static NTSTATUS thunk64_vkCopyMemoryToAccelerationStructureKHR(void *args)
{
@ -32545,6 +33120,39 @@ static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args)
return STATUS_SUCCESS;
}
#ifdef _WIN64
static NTSTATUS thunk64_vkCopyMemoryToImageEXT(void *args)
{
struct vkCopyMemoryToImageEXT_params *params = args;
TRACE("%p, %p\n", params->device, params->pCopyMemoryToImageInfo);
params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToImageEXT(wine_device_from_handle(params->device)->device, params->pCopyMemoryToImageInfo);
return STATUS_SUCCESS;
}
#endif /* _WIN64 */
static NTSTATUS thunk32_vkCopyMemoryToImageEXT(void *args)
{
struct
{
PTR32 device;
PTR32 pCopyMemoryToImageInfo;
VkResult result;
} *params = args;
VkCopyMemoryToImageInfoEXT pCopyMemoryToImageInfo_host;
struct conversion_context local_ctx;
struct conversion_context *ctx = &local_ctx;
TRACE("%#x, %#x\n", params->device, params->pCopyMemoryToImageInfo);
init_conversion_context(ctx);
convert_VkCopyMemoryToImageInfoEXT_win32_to_host(ctx, (const VkCopyMemoryToImageInfoEXT32 *)UlongToPtr(params->pCopyMemoryToImageInfo), &pCopyMemoryToImageInfo_host);
params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMemoryToImageEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCopyMemoryToImageInfo_host);
free_conversion_context(ctx);
return STATUS_SUCCESS;
}
#ifdef _WIN64
static NTSTATUS thunk64_vkCopyMemoryToMicromapEXT(void *args)
{
@ -37896,6 +38504,41 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *arg
return STATUS_SUCCESS;
}
#ifdef _WIN64
static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(void *args)
{
struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params *params = args;
TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPropertyCount, params->pProperties);
return STATUS_SUCCESS;
}
#endif /* _WIN64 */
static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(void *args)
{
struct
{
PTR32 physicalDevice;
PTR32 pPropertyCount;
PTR32 pProperties;
VkResult result;
} *params = args;
VkCooperativeMatrixPropertiesKHR *pProperties_host;
struct conversion_context local_ctx;
struct conversion_context *ctx = &local_ctx;
TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
init_conversion_context(ctx);
pProperties_host = convert_VkCooperativeMatrixPropertiesKHR_array_win32_to_host(ctx, (VkCooperativeMatrixPropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host);
convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32(pProperties_host, (VkCooperativeMatrixPropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
free_conversion_context(ctx);
return STATUS_SUCCESS;
}
#ifdef _WIN64
static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
{
@ -41165,6 +41808,40 @@ static NTSTATUS thunk32_vkSubmitDebugUtilsMessageEXT(void *args)
return STATUS_SUCCESS;
}
#ifdef _WIN64
static NTSTATUS thunk64_vkTransitionImageLayoutEXT(void *args)
{
struct vkTransitionImageLayoutEXT_params *params = args;
TRACE("%p, %u, %p\n", params->device, params->transitionCount, params->pTransitions);
params->result = wine_device_from_handle(params->device)->funcs.p_vkTransitionImageLayoutEXT(wine_device_from_handle(params->device)->device, params->transitionCount, params->pTransitions);
return STATUS_SUCCESS;
}
#endif /* _WIN64 */
static NTSTATUS thunk32_vkTransitionImageLayoutEXT(void *args)
{
struct
{
PTR32 device;
uint32_t transitionCount;
PTR32 pTransitions;
VkResult result;
} *params = args;
const VkHostImageLayoutTransitionInfoEXT *pTransitions_host;
struct conversion_context local_ctx;
struct conversion_context *ctx = &local_ctx;
TRACE("%#x, %u, %#x\n", params->device, params->transitionCount, params->pTransitions);
init_conversion_context(ctx);
pTransitions_host = convert_VkHostImageLayoutTransitionInfoEXT_array_win32_to_host(ctx, (const VkHostImageLayoutTransitionInfoEXT32 *)UlongToPtr(params->pTransitions), params->transitionCount);
params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkTransitionImageLayoutEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->transitionCount, pTransitions_host);
free_conversion_context(ctx);
return STATUS_SUCCESS;
}
#ifdef _WIN64
static NTSTATUS thunk64_vkTrimCommandPool(void *args)
{
@ -41626,6 +42303,7 @@ static const char * const vk_device_extensions[] =
"VK_EXT_global_priority_query",
"VK_EXT_graphics_pipeline_library",
"VK_EXT_hdr_metadata",
"VK_EXT_host_image_copy",
"VK_EXT_host_query_reset",
"VK_EXT_image_2d_view_of_3d",
"VK_EXT_image_compression_control",
@ -41705,6 +42383,7 @@ static const char * const vk_device_extensions[] =
"VK_KHR_acceleration_structure",
"VK_KHR_bind_memory2",
"VK_KHR_buffer_device_address",
"VK_KHR_cooperative_matrix",
"VK_KHR_copy_commands2",
"VK_KHR_create_renderpass2",
"VK_KHR_dedicated_allocation",
@ -42136,7 +42815,10 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
thunk64_vkCompileDeferredNV,
thunk64_vkCopyAccelerationStructureKHR,
thunk64_vkCopyAccelerationStructureToMemoryKHR,
thunk64_vkCopyImageToImageEXT,
thunk64_vkCopyImageToMemoryEXT,
thunk64_vkCopyMemoryToAccelerationStructureKHR,
thunk64_vkCopyMemoryToImageEXT,
thunk64_vkCopyMemoryToMicromapEXT,
thunk64_vkCopyMicromapEXT,
thunk64_vkCopyMicromapToMemoryEXT,
@ -42307,6 +42989,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
thunk64_vkGetMicromapBuildSizesEXT,
thunk64_vkGetPerformanceParameterINTEL,
thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR,
thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
thunk64_vkGetPhysicalDeviceExternalBufferProperties,
thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
@ -42410,6 +43093,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
thunk64_vkSignalSemaphore,
thunk64_vkSignalSemaphoreKHR,
thunk64_vkSubmitDebugUtilsMessageEXT,
thunk64_vkTransitionImageLayoutEXT,
thunk64_vkTrimCommandPool,
thunk64_vkTrimCommandPoolKHR,
thunk64_vkUninitializePerformanceApiINTEL,
@ -42691,7 +43375,10 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
thunk32_vkCompileDeferredNV,
thunk32_vkCopyAccelerationStructureKHR,
thunk32_vkCopyAccelerationStructureToMemoryKHR,
thunk32_vkCopyImageToImageEXT,
thunk32_vkCopyImageToMemoryEXT,
thunk32_vkCopyMemoryToAccelerationStructureKHR,
thunk32_vkCopyMemoryToImageEXT,
thunk32_vkCopyMemoryToMicromapEXT,
thunk32_vkCopyMicromapEXT,
thunk32_vkCopyMicromapToMemoryEXT,
@ -42862,6 +43549,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
thunk32_vkGetMicromapBuildSizesEXT,
thunk32_vkGetPerformanceParameterINTEL,
thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR,
thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
thunk32_vkGetPhysicalDeviceExternalBufferProperties,
thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
@ -42965,6 +43653,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
thunk32_vkSignalSemaphore,
thunk32_vkSignalSemaphoreKHR,
thunk32_vkSubmitDebugUtilsMessageEXT,
thunk32_vkTransitionImageLayoutEXT,
thunk32_vkTrimCommandPool,
thunk32_vkTrimCommandPoolKHR,
thunk32_vkUninitializePerformanceApiINTEL,

10
dlls/winevulkan/vulkan_thunks.h
View file

@ -317,7 +317,10 @@ struct vulkan_device_funcs
VkResult (*p_vkCompileDeferredNV)(VkDevice, VkPipeline, uint32_t);
VkResult (*p_vkCopyAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureInfoKHR *);
VkResult (*p_vkCopyAccelerationStructureToMemoryKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureToMemoryInfoKHR *);
VkResult (*p_vkCopyImageToImageEXT)(VkDevice, const VkCopyImageToImageInfoEXT *);
VkResult (*p_vkCopyImageToMemoryEXT)(VkDevice, const VkCopyImageToMemoryInfoEXT *);
VkResult (*p_vkCopyMemoryToAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToAccelerationStructureInfoKHR *);
VkResult (*p_vkCopyMemoryToImageEXT)(VkDevice, const VkCopyMemoryToImageInfoEXT *);
VkResult (*p_vkCopyMemoryToMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToMicromapInfoEXT *);
VkResult (*p_vkCopyMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapInfoEXT *);
VkResult (*p_vkCopyMicromapToMemoryEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapToMemoryInfoEXT *);
@ -528,6 +531,7 @@ struct vulkan_device_funcs
VkResult (*p_vkSetPrivateDataEXT)(VkDevice, VkObjectType, uint64_t, VkPrivateDataSlot, uint64_t);
VkResult (*p_vkSignalSemaphore)(VkDevice, const VkSemaphoreSignalInfo *);
VkResult (*p_vkSignalSemaphoreKHR)(VkDevice, const VkSemaphoreSignalInfo *);
VkResult (*p_vkTransitionImageLayoutEXT)(VkDevice, uint32_t, const VkHostImageLayoutTransitionInfoEXT *);
void (*p_vkTrimCommandPool)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags);
void (*p_vkTrimCommandPoolKHR)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags);
void (*p_vkUninitializePerformanceApiINTEL)(VkDevice);
@ -563,6 +567,7 @@ struct vulkan_instance_funcs
VkResult (*p_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice, uint32_t *, VkLayerProperties *);
VkResult (*p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice, uint32_t, uint32_t *, VkPerformanceCounterKHR *, VkPerformanceCounterDescriptionKHR *);
VkResult (*p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainEXT *);
VkResult (*p_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesKHR *);
VkResult (*p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesNV *);
void (*p_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice, VkPhysicalDeviceFeatures *);
void (*p_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice, VkPhysicalDeviceFeatures2 *);
@ -856,7 +861,10 @@ struct vulkan_instance_funcs
USE_VK_FUNC(vkCompileDeferredNV) \
USE_VK_FUNC(vkCopyAccelerationStructureKHR) \
USE_VK_FUNC(vkCopyAccelerationStructureToMemoryKHR) \
USE_VK_FUNC(vkCopyImageToImageEXT) \
USE_VK_FUNC(vkCopyImageToMemoryEXT) \
USE_VK_FUNC(vkCopyMemoryToAccelerationStructureKHR) \
USE_VK_FUNC(vkCopyMemoryToImageEXT) \
USE_VK_FUNC(vkCopyMemoryToMicromapEXT) \
USE_VK_FUNC(vkCopyMicromapEXT) \
USE_VK_FUNC(vkCopyMicromapToMemoryEXT) \
@ -1067,6 +1075,7 @@ struct vulkan_instance_funcs
USE_VK_FUNC(vkSetPrivateDataEXT) \
USE_VK_FUNC(vkSignalSemaphore) \
USE_VK_FUNC(vkSignalSemaphoreKHR) \
USE_VK_FUNC(vkTransitionImageLayoutEXT) \
USE_VK_FUNC(vkTrimCommandPool) \
USE_VK_FUNC(vkTrimCommandPoolKHR) \
USE_VK_FUNC(vkUninitializePerformanceApiINTEL) \
@ -1099,6 +1108,7 @@ struct vulkan_instance_funcs
USE_VK_FUNC(vkEnumerateDeviceLayerProperties) \
USE_VK_FUNC(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR) \
USE_VK_FUNC(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT) \
USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR) \
USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV) \
USE_VK_FUNC(vkGetPhysicalDeviceFeatures) \
USE_VK_FUNC(vkGetPhysicalDeviceFeatures2) \

2
dlls/winevulkan/winevulkan.json
View file

@ -2,6 +2,6 @@
"file_format_version": "1.0.0",
"ICD": {
"library_path": ".\\winevulkan.dll",
"api_version": "1.3.254"
"api_version": "1.3.258"
}
}

233
include/wine/vulkan.h
View file

@ -403,6 +403,8 @@
#define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations"
#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
#define VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION 1
#define VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME "VK_EXT_host_image_copy"
#define VK_KHR_MAP_MEMORY_2_SPEC_VERSION 1
#define VK_KHR_MAP_MEMORY_2_EXTENSION_NAME "VK_KHR_map_memory2"
#define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1
@ -503,7 +505,7 @@
#define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME "VK_EXT_primitive_topology_list_restart"
#define VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION 2
#define VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME "VK_KHR_format_feature_flags2"
#define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 2
#define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 3
#define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading"
#define VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION 1
#define VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME "VK_HUAWEI_invocation_mask"
@ -599,6 +601,8 @@
#define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME "VK_EXT_pipeline_library_group_handles"
#define VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION 1
#define VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME "VK_EXT_dynamic_rendering_unused_attachments"
#define VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION 2
#define VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_KHR_cooperative_matrix"
#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1
#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME "VK_QCOM_multiview_per_view_render_areas"
#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION 1
@ -629,7 +633,7 @@
#define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)
#define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0)
#define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)
#define VK_HEADER_VERSION 254
#define VK_HEADER_VERSION 258
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
#define VK_USE_64_BIT_PTR_DEFINES 0
@ -798,6 +802,7 @@ typedef VkFlags VkGeometryInstanceFlagsKHR;
typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV;
typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT;
typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT;
typedef VkFlags VkHostImageCopyFlagsEXT;
typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
typedef VkFlags VkImageAspectFlags;
typedef VkFlags VkImageCompressionFixedRateFlagsEXT;
@ -1414,21 +1419,33 @@ typedef enum VkComponentSwizzle
VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7fffffff,
} VkComponentSwizzle;
typedef enum VkComponentTypeNV
typedef enum VkComponentTypeKHR
{
VK_COMPONENT_TYPE_FLOAT16_NV = 0,
VK_COMPONENT_TYPE_FLOAT32_NV = 1,
VK_COMPONENT_TYPE_FLOAT64_NV = 2,
VK_COMPONENT_TYPE_SINT8_NV = 3,
VK_COMPONENT_TYPE_SINT16_NV = 4,
VK_COMPONENT_TYPE_SINT32_NV = 5,
VK_COMPONENT_TYPE_SINT64_NV = 6,
VK_COMPONENT_TYPE_UINT8_NV = 7,
VK_COMPONENT_TYPE_UINT16_NV = 8,
VK_COMPONENT_TYPE_UINT32_NV = 9,
VK_COMPONENT_TYPE_UINT64_NV = 10,
VK_COMPONENT_TYPE_NV_MAX_ENUM = 0x7fffffff,
} VkComponentTypeNV;
VK_COMPONENT_TYPE_FLOAT16_KHR = 0,
VK_COMPONENT_TYPE_FLOAT32_KHR = 1,
VK_COMPONENT_TYPE_FLOAT64_KHR = 2,
VK_COMPONENT_TYPE_SINT8_KHR = 3,
VK_COMPONENT_TYPE_SINT16_KHR = 4,
VK_COMPONENT_TYPE_SINT32_KHR = 5,
VK_COMPONENT_TYPE_SINT64_KHR = 6,
VK_COMPONENT_TYPE_UINT8_KHR = 7,
VK_COMPONENT_TYPE_UINT16_KHR = 8,
VK_COMPONENT_TYPE_UINT32_KHR = 9,
VK_COMPONENT_TYPE_UINT64_KHR = 10,
VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR,
VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR,
VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR,
VK_COMPONENT_TYPE_SINT8_NV = VK_COMPONENT_TYPE_SINT8_KHR,
VK_COMPONENT_TYPE_SINT16_NV = VK_COMPONENT_TYPE_SINT16_KHR,
VK_COMPONENT_TYPE_SINT32_NV = VK_COMPONENT_TYPE_SINT32_KHR,
VK_COMPONENT_TYPE_SINT64_NV = VK_COMPONENT_TYPE_SINT64_KHR,
VK_COMPONENT_TYPE_UINT8_NV = VK_COMPONENT_TYPE_UINT8_KHR,
VK_COMPONENT_TYPE_UINT16_NV = VK_COMPONENT_TYPE_UINT16_KHR,
VK_COMPONENT_TYPE_UINT32_NV = VK_COMPONENT_TYPE_UINT32_KHR,
VK_COMPONENT_TYPE_UINT64_NV = VK_COMPONENT_TYPE_UINT64_KHR,
VK_COMPONENT_TYPE_KHR_MAX_ENUM = 0x7fffffff,
} VkComponentTypeKHR;
typedef VkComponentTypeKHR VkComponentTypeNV;
typedef enum VkCompositeAlphaFlagBitsKHR
{
@ -2391,6 +2408,7 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMEN
static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0x10000000000ull;
static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ull;
static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ull;
static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ull;
typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR;
typedef enum VkFragmentShadingRateCombinerOpKHR
@ -2488,6 +2506,12 @@ typedef enum VkGraphicsPipelineLibraryFlagBitsEXT
VK_GRAPHICS_PIPELINE_LIBRARY_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff,
} VkGraphicsPipelineLibraryFlagBitsEXT;
typedef enum VkHostImageCopyFlagBitsEXT
{
VK_HOST_IMAGE_COPY_MEMCPY_EXT = 0x00000001,
VK_HOST_IMAGE_COPY_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff,
} VkHostImageCopyFlagBitsEXT;
typedef enum VkImageAspectFlagBits
{
VK_IMAGE_ASPECT_NONE = 0,
@ -2640,6 +2664,7 @@ typedef enum VkImageUsageFlagBits
VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000,
VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000,
VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000,
VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = 0x00400000,
VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
} VkImageUsageFlagBits;
@ -3279,6 +3304,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT
static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ull;
static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ull;
static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ull;
static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI = 0x8000000000ull;
static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ull;
static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ull;
static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0x20000000000ull;
@ -3625,14 +3651,19 @@ typedef enum VkSamplerYcbcrRange
} VkSamplerYcbcrRange;
typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;
typedef enum VkScopeNV
typedef enum VkScopeKHR
{
VK_SCOPE_DEVICE_NV = 1,
VK_SCOPE_WORKGROUP_NV = 2,
VK_SCOPE_SUBGROUP_NV = 3,
VK_SCOPE_QUEUE_FAMILY_NV = 5,
VK_SCOPE_NV_MAX_ENUM = 0x7fffffff,
} VkScopeNV;
VK_SCOPE_DEVICE_KHR = 1,
VK_SCOPE_WORKGROUP_KHR = 2,
VK_SCOPE_SUBGROUP_KHR = 3,
VK_SCOPE_QUEUE_FAMILY_KHR = 5,
VK_SCOPE_DEVICE_NV = VK_SCOPE_DEVICE_KHR,
VK_SCOPE_WORKGROUP_NV = VK_SCOPE_WORKGROUP_KHR,
VK_SCOPE_SUBGROUP_NV = VK_SCOPE_SUBGROUP_KHR,
VK_SCOPE_QUEUE_FAMILY_NV = VK_SCOPE_QUEUE_FAMILY_KHR,
VK_SCOPE_KHR_MAX_ENUM = 0x7fffffff,
} VkScopeKHR;
typedef VkScopeKHR VkScopeNV;
typedef enum VkSemaphoreImportFlagBits
{
@ -4180,6 +4211,16 @@ typedef enum VkStructureType
VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT = 1000270000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT = 1000270001,
VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT = 1000270002,
VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT = 1000270003,
VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT = 1000270004,
VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT = 1000270005,
VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT = 1000270006,
VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT = 1000270007,
VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT = 1000270008,
VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = 1000270009,
VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = 1000271000,
VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = 1000271001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000,
@ -4406,6 +4447,9 @@ typedef enum VkStructureType
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT = 1000499000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000,
VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000,
VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000,
@ -5373,6 +5417,21 @@ typedef struct VkConformanceVersion
} VkConformanceVersion;
typedef VkConformanceVersion VkConformanceVersionKHR;
typedef struct VkCooperativeMatrixPropertiesKHR
{
VkStructureType sType;
void *pNext;
uint32_t MSize;
uint32_t NSize;
uint32_t KSize;
VkComponentTypeKHR AType;
VkComponentTypeKHR BType;
VkComponentTypeKHR CType;
VkComponentTypeKHR ResultType;
VkBool32 saturatingAccumulation;
VkScopeKHR scope;
} VkCooperativeMatrixPropertiesKHR;
typedef struct VkCooperativeMatrixPropertiesNV
{
VkStructureType sType;
@ -6214,6 +6273,14 @@ typedef struct VkGraphicsPipelineLibraryCreateInfoEXT
VkGraphicsPipelineLibraryFlagsEXT flags;
} VkGraphicsPipelineLibraryCreateInfoEXT;
typedef struct VkHostImageCopyDevicePerformanceQueryEXT
{
VkStructureType sType;
void *pNext;
VkBool32 optimalDeviceAccess;
VkBool32 identicalMemoryLayout;
} VkHostImageCopyDevicePerformanceQueryEXT;
typedef struct VkImageCaptureDescriptorDataInfoEXT
{
VkStructureType sType;
@ -7066,6 +7133,14 @@ typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT
VkBool32 conservativeRasterizationPostDepthCoverage;
} VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR
{
VkStructureType sType;
void *pNext;
VkBool32 cooperativeMatrix;
VkBool32 cooperativeMatrixRobustBufferAccess;
} VkPhysicalDeviceCooperativeMatrixFeaturesKHR;
typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV
{
VkStructureType sType;
@ -7074,6 +7149,13 @@ typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV
VkBool32 cooperativeMatrixRobustBufferAccess;
} VkPhysicalDeviceCooperativeMatrixFeaturesNV;
typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR
{
VkStructureType sType;
void *pNext;
VkShaderStageFlags cooperativeMatrixSupportedStages;
} VkPhysicalDeviceCooperativeMatrixPropertiesKHR;
typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV
{
VkStructureType sType;
@ -7724,6 +7806,25 @@ typedef struct VkPhysicalDeviceGroupProperties
} VkPhysicalDeviceGroupProperties;
typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;
typedef struct VkPhysicalDeviceHostImageCopyFeaturesEXT
{
VkStructureType sType;
void *pNext;
VkBool32 hostImageCopy;
} VkPhysicalDeviceHostImageCopyFeaturesEXT;
typedef struct VkPhysicalDeviceHostImageCopyPropertiesEXT
{
VkStructureType sType;
void *pNext;
uint32_t copySrcLayoutCount;
VkImageLayout *pCopySrcLayouts;
uint32_t copyDstLayoutCount;
VkImageLayout *pCopyDstLayouts;
uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
VkBool32 identicalMemoryTypeRequirements;
} VkPhysicalDeviceHostImageCopyPropertiesEXT;
typedef struct VkPhysicalDeviceHostQueryResetFeatures
{
VkStructureType sType;
@ -10508,6 +10609,13 @@ typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI
uint32_t subpass;
} VkSubpassShadingPipelineCreateInfoHUAWEI;
typedef struct VkSubresourceHostMemcpySizeEXT
{
VkStructureType sType;
void *pNext;
VkDeviceSize WINE_VK_ALIGN(8) size;
} VkSubresourceHostMemcpySizeEXT;
typedef struct VkSubresourceLayout
{
VkDeviceSize WINE_VK_ALIGN(8) offset;
@ -11245,6 +11353,16 @@ typedef struct VkHdrMetadataEXT
float maxFrameAverageLightLevel;
} VkHdrMetadataEXT;
typedef struct VkHostImageLayoutTransitionInfoEXT
{
VkStructureType sType;
const void *pNext;
VkImage WINE_VK_ALIGN(8) image;
VkImageLayout oldLayout;
VkImageLayout newLayout;
VkImageSubresourceRange subresourceRange;
} VkHostImageLayoutTransitionInfoEXT;
typedef struct VkImageBlit
{
VkImageSubresourceLayers srcSubresource;
@ -11337,6 +11455,18 @@ typedef struct VkImageResolve2
} VkImageResolve2;
typedef VkImageResolve2 VkImageResolve2KHR;
typedef struct VkImageToMemoryCopyEXT
{
VkStructureType sType;
const void *pNext;
void *pHostPointer;
uint32_t memoryRowLength;
uint32_t memoryImageHeight;
VkImageSubresourceLayers imageSubresource;
VkOffset3D imageOffset;
VkExtent3D imageExtent;
} VkImageToMemoryCopyEXT;
typedef struct VkImageViewSampleWeightCreateInfoQCOM
{
VkStructureType sType;
@ -11358,6 +11488,18 @@ typedef struct VkIndirectCommandsLayoutCreateInfoNV
const uint32_t *pStreamStrides;
} VkIndirectCommandsLayoutCreateInfoNV;
typedef struct VkMemoryToImageCopyEXT
{
VkStructureType sType;
const void *pNext;
const void *pHostPointer;
uint32_t memoryRowLength;
uint32_t memoryImageHeight;
VkImageSubresourceLayers imageSubresource;
VkOffset3D imageOffset;
VkExtent3D imageExtent;
} VkMemoryToImageCopyEXT;
typedef struct VkMicromapBuildInfoEXT
{
VkStructureType sType;
@ -11742,6 +11884,41 @@ typedef struct VkCopyImageInfo2
} VkCopyImageInfo2;
typedef VkCopyImageInfo2 VkCopyImageInfo2KHR;
typedef struct VkCopyImageToImageInfoEXT
{
VkStructureType sType;
const void *pNext;
VkHostImageCopyFlagsEXT flags;
VkImage WINE_VK_ALIGN(8) srcImage;
VkImageLayout srcImageLayout;
VkImage WINE_VK_ALIGN(8) dstImage;
VkImageLayout dstImageLayout;
uint32_t regionCount;
const VkImageCopy2 *pRegions;
} VkCopyImageToImageInfoEXT;
typedef struct VkCopyImageToMemoryInfoEXT
{
VkStructureType sType;
const void *pNext;
VkHostImageCopyFlagsEXT flags;
VkImage WINE_VK_ALIGN(8) srcImage;
VkImageLayout srcImageLayout;
uint32_t regionCount;
const VkImageToMemoryCopyEXT *pRegions;
} VkCopyImageToMemoryInfoEXT;
typedef struct VkCopyMemoryToImageInfoEXT
{
VkStructureType sType;
const void *pNext;
VkHostImageCopyFlagsEXT flags;
VkImage WINE_VK_ALIGN(8) dstImage;
VkImageLayout dstImageLayout;
uint32_t regionCount;
const VkMemoryToImageCopyEXT *pRegions;
} VkCopyMemoryToImageInfoEXT;
typedef struct VkDependencyInfo
{
VkStructureType sType;
@ -12148,7 +12325,10 @@ typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer, VkPipelin
typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice, VkPipeline, uint32_t);
typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureInfoKHR *);
typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureToMemoryInfoKHR *);
typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToImageEXT)(VkDevice, const VkCopyImageToImageInfoEXT *);
typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToMemoryEXT)(VkDevice, const VkCopyImageToMemoryInfoEXT *);
typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToAccelerationStructureInfoKHR *);
typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToImageEXT)(VkDevice, const VkCopyMemoryToImageInfoEXT *);
typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToMicromapInfoEXT *);
typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapInfoEXT *);
typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapToMemoryInfoEXT *);
@ -12324,6 +12504,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice,
typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice, VkAccelerationStructureBuildTypeKHR, const VkMicromapBuildInfoEXT *, VkMicromapBuildSizesInfoEXT *);
typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice, VkPerformanceParameterTypeINTEL, VkPerformanceValueINTEL *);
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainEXT *);
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesKHR *);
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesNV *);
typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice, const VkPhysicalDeviceExternalBufferInfo *, VkExternalBufferProperties *);
typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice, const VkPhysicalDeviceExternalBufferInfo *, VkExternalBufferProperties *);
@ -12427,6 +12608,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice, VkObjectType, ui
typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice, const VkSemaphoreSignalInfo *);
typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice, const VkSemaphoreSignalInfo *);
typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance, VkDebugUtilsMessageSeverityFlagBitsEXT, VkDebugUtilsMessageTypeFlagsEXT, const VkDebugUtilsMessengerCallbackDataEXT *);
typedef VkResult (VKAPI_PTR *PFN_vkTransitionImageLayoutEXT)(VkDevice, uint32_t, const VkHostImageLayoutTransitionInfoEXT *);
typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags);
typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags);
typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice);
@ -12696,7 +12878,10 @@ void VKAPI_CALL vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelin
VkResult VKAPI_CALL vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader);
VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo);
VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo);
VkResult VKAPI_CALL vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfoEXT *pCopyImageToImageInfo);
VkResult VKAPI_CALL vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfoEXT *pCopyImageToMemoryInfo);
VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo);
VkResult VKAPI_CALL vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfoEXT *pCopyMemoryToImageInfo);
VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo);
VkResult VKAPI_CALL vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo);
VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo);
@ -12872,6 +13057,7 @@ VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExter
void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo);
VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue);
VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains);
VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties);
VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties);
void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties);
void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties);
@ -12975,6 +13161,7 @@ VkResult VKAPI_CALL vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType
VkResult VKAPI_CALL vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo);
VkResult VKAPI_CALL vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo);
void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData);
VkResult VKAPI_CALL vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT *pTransitions);
void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
void VKAPI_CALL vkUninitializePerformanceApiINTEL(VkDevice device);