On 2016-11-10 17:45:10, Dave Airlie wrote: > From: Dave Airlie <airl...@redhat.com> > > I just noticed the new vulkan headers changed a prototype, > so I've decided to import them and fix the drivers to use the > new API. >
The new header is Apache licensed. I know that the FSF says Apache is not compatible with GPLv2 code. https://www.gnu.org/licenses/license-list.en.html#apache2 I think GPLv2 code can include "system library headers" under non-GPLv2 compatible libraries, so this should be okay for GPLv2 licensed code. For example, GPLv2 code can include stdio.h, even if on some systems the stdio.h may have a non-GPLv2 compatible license. Is that correct? -Jordan > > Signed-off-by: Dave Airlie <airl...@redhat.com> > --- > include/vulkan/vk_platform.h | 39 ++-- > include/vulkan/vulkan.h | 429 > +++++++++++++++++++++++++++++++++++--- > src/amd/vulkan/radv_meta_buffer.c | 2 +- > src/intel/vulkan/anv_blorp.c | 2 +- > 4 files changed, 413 insertions(+), 59 deletions(-) > > diff --git a/include/vulkan/vk_platform.h b/include/vulkan/vk_platform.h > index f5a5243..0fa62ee 100644 > --- a/include/vulkan/vk_platform.h > +++ b/include/vulkan/vk_platform.h > @@ -4,24 +4,17 @@ > /* > ** Copyright (c) 2014-2015 The Khronos Group Inc. > ** > -** Permission is hereby granted, free of charge, to any person obtaining a > -** copy of this software and/or associated documentation files (the > -** "Materials"), to deal in the Materials without restriction, including > -** without limitation the rights to use, copy, modify, merge, publish, > -** distribute, sublicense, and/or sell copies of the Materials, and to > -** permit persons to whom the Materials are furnished to do so, subject to > -** the following conditions: > +** Licensed under the Apache License, Version 2.0 (the "License"); > +** you may not use this file except in compliance with the License. > +** You may obtain a copy of the License at > ** > -** The above copyright notice and this permission notice shall be included > -** in all copies or substantial portions of the Materials. > +** http://www.apache.org/licenses/LICENSE-2.0 > ** > -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, > -** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF > -** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. > -** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY > -** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, > -** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE > -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. > +** Unless required by applicable law or agreed to in writing, software > +** distributed under the License is distributed on an "AS IS" BASIS, > +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. > +** See the License for the specific language governing permissions and > +** limitations under the License. > */ > > > @@ -58,13 +51,13 @@ extern "C" > #define VKAPI_ATTR > #define VKAPI_CALL __stdcall > #define VKAPI_PTR VKAPI_CALL > -#elif defined(__ANDROID__) && defined(__ARM_EABI__) && > !defined(__ARM_ARCH_7A__) > - // Android does not support Vulkan in native code using the "armeabi" > ABI. > - #error "Vulkan requires the 'armeabi-v7a' or 'armeabi-v7a-hard' ABI on > 32-bit ARM CPUs" > -#elif defined(__ANDROID__) && defined(__ARM_ARCH_7A__) > - // On Android/ARMv7a, Vulkan functions use the armeabi-v7a-hard calling > - // convention, even if the application's native code is compiled with the > - // armeabi-v7a calling convention. > +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7 > + #error "Vulkan isn't supported for the 'armeabi' NDK ABI" > +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && > defined(__ARM_32BIT_STATE) > + // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat" > + // calling convention, i.e. float parameters are passed in registers. > This > + // is true even if the rest of the application passes floats on the > stack, > + // as it does by default when compiling for the armeabi-v7a NDK ABI. > #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp"))) > #define VKAPI_CALL > #define VKAPI_PTR VKAPI_ATTR > diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h > index 567671a..694527c 100644 > --- a/include/vulkan/vulkan.h > +++ b/include/vulkan/vulkan.h > @@ -8,24 +8,17 @@ extern "C" { > /* > ** Copyright (c) 2015-2016 The Khronos Group Inc. > ** > -** Permission is hereby granted, free of charge, to any person obtaining a > -** copy of this software and/or associated documentation files (the > -** "Materials"), to deal in the Materials without restriction, including > -** without limitation the rights to use, copy, modify, merge, publish, > -** distribute, sublicense, and/or sell copies of the Materials, and to > -** permit persons to whom the Materials are furnished to do so, subject to > -** the following conditions: > +** Licensed under the Apache License, Version 2.0 (the "License"); > +** you may not use this file except in compliance with the License. > +** You may obtain a copy of the License at > ** > -** The above copyright notice and this permission notice shall be included > -** in all copies or substantial portions of the Materials. > +** http://www.apache.org/licenses/LICENSE-2.0 > ** > -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, > -** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF > -** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. > -** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY > -** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, > -** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE > -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. > +** Unless required by applicable law or agreed to in writing, software > +** distributed under the License is distributed on an "AS IS" BASIS, > +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. > +** See the License for the specific language governing permissions and > +** limitations under the License. > */ > > /* > @@ -50,7 +43,7 @@ extern "C" { > #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) > #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) > // Version of this file > -#define VK_HEADER_VERSION 6 > +#define VK_HEADER_VERSION 32 > > > #define VK_NULL_HANDLE 0 > @@ -60,11 +53,13 @@ extern "C" { > #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; > > > -#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || > defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || > defined(__aarch64__) || defined(__powerpc64__) > +#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE) > +#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && > !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined > (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) > #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct > object##_T *object; > #else > #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t > object; > #endif > +#endif > > > > @@ -142,6 +137,7 @@ typedef enum VkResult { > VK_ERROR_INCOMPATIBLE_DRIVER = -9, > VK_ERROR_TOO_MANY_OBJECTS = -10, > VK_ERROR_FORMAT_NOT_SUPPORTED = -11, > + VK_ERROR_FRAGMENTED_POOL = -12, > VK_ERROR_SURFACE_LOST_KHR = -1000000000, > VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, > VK_SUBOPTIMAL_KHR = 1000001003, > @@ -149,9 +145,9 @@ typedef enum VkResult { > VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, > VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, > VK_ERROR_INVALID_SHADER_NV = -1000012000, > - VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED, > + VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, > VK_RESULT_END_RANGE = VK_INCOMPLETE, > - VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + > 1), > + VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1), > VK_RESULT_MAX_ENUM = 0x7FFFFFFF > } VkResult; > > @@ -217,6 +213,19 @@ typedef enum VkStructureType { > VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, > VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, > VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, > + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = > 1000018000, > + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, > + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, > + VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, > + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, > + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = > 1000026001, > + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = > 1000026002, > + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, > + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, > + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, > + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, > + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, > + VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, > VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, > VK_STRUCTURE_TYPE_END_RANGE = > VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, > VK_STRUCTURE_TYPE_RANGE_SIZE = > (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - > VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), > @@ -429,6 +438,14 @@ typedef enum VkFormat { > VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, > VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, > VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, > + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, > + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, > + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, > + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, > + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, > + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, > + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, > + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, > VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, > VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, > VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - > VK_FORMAT_UNDEFINED + 1), > @@ -817,6 +834,7 @@ typedef enum VkFormatFeatureFlagBits { > VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, > VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, > VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, > + VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkFormatFeatureFlagBits; > typedef VkFlags VkFormatFeatureFlags; > > @@ -829,6 +847,7 @@ typedef enum VkImageUsageFlagBits { > VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, > VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, > VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, > + VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkImageUsageFlagBits; > typedef VkFlags VkImageUsageFlags; > > @@ -838,6 +857,7 @@ typedef enum VkImageCreateFlagBits { > VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, > VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, > VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, > + VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkImageCreateFlagBits; > typedef VkFlags VkImageCreateFlags; > > @@ -849,6 +869,7 @@ typedef enum VkSampleCountFlagBits { > VK_SAMPLE_COUNT_16_BIT = 0x00000010, > VK_SAMPLE_COUNT_32_BIT = 0x00000020, > VK_SAMPLE_COUNT_64_BIT = 0x00000040, > + VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkSampleCountFlagBits; > typedef VkFlags VkSampleCountFlags; > > @@ -857,6 +878,7 @@ typedef enum VkQueueFlagBits { > VK_QUEUE_COMPUTE_BIT = 0x00000002, > VK_QUEUE_TRANSFER_BIT = 0x00000004, > VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, > + VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkQueueFlagBits; > typedef VkFlags VkQueueFlags; > > @@ -866,11 +888,13 @@ typedef enum VkMemoryPropertyFlagBits { > VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, > VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, > VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, > + VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkMemoryPropertyFlagBits; > typedef VkFlags VkMemoryPropertyFlags; > > typedef enum VkMemoryHeapFlagBits { > VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, > + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkMemoryHeapFlagBits; > typedef VkFlags VkMemoryHeapFlags; > typedef VkFlags VkDeviceCreateFlags; > @@ -894,6 +918,7 @@ typedef enum VkPipelineStageFlagBits { > VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, > VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, > VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, > + VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkPipelineStageFlagBits; > typedef VkFlags VkPipelineStageFlags; > typedef VkFlags VkMemoryMapFlags; > @@ -903,6 +928,7 @@ typedef enum VkImageAspectFlagBits { > VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, > VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, > VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, > + VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkImageAspectFlagBits; > typedef VkFlags VkImageAspectFlags; > > @@ -910,16 +936,19 @@ typedef enum VkSparseImageFormatFlagBits { > VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, > VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, > VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, > + VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkSparseImageFormatFlagBits; > typedef VkFlags VkSparseImageFormatFlags; > > typedef enum VkSparseMemoryBindFlagBits { > VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, > + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkSparseMemoryBindFlagBits; > typedef VkFlags VkSparseMemoryBindFlags; > > typedef enum VkFenceCreateFlagBits { > VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, > + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkFenceCreateFlagBits; > typedef VkFlags VkFenceCreateFlags; > typedef VkFlags VkSemaphoreCreateFlags; > @@ -938,6 +967,7 @@ typedef enum VkQueryPipelineStatisticFlagBits { > VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = > 0x00000100, > > VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = > 0x00000200, > VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, > + VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkQueryPipelineStatisticFlagBits; > typedef VkFlags VkQueryPipelineStatisticFlags; > > @@ -946,6 +976,7 @@ typedef enum VkQueryResultFlagBits { > VK_QUERY_RESULT_WAIT_BIT = 0x00000002, > VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, > VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, > + VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkQueryResultFlagBits; > typedef VkFlags VkQueryResultFlags; > > @@ -953,6 +984,7 @@ typedef enum VkBufferCreateFlagBits { > VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, > VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, > VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, > + VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkBufferCreateFlagBits; > typedef VkFlags VkBufferCreateFlags; > > @@ -966,6 +998,7 @@ typedef enum VkBufferUsageFlagBits { > VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, > VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, > VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, > + VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkBufferUsageFlagBits; > typedef VkFlags VkBufferUsageFlags; > typedef VkFlags VkBufferViewCreateFlags; > @@ -977,6 +1010,7 @@ typedef enum VkPipelineCreateFlagBits { > VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, > VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, > VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, > + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkPipelineCreateFlagBits; > typedef VkFlags VkPipelineCreateFlags; > typedef VkFlags VkPipelineShaderStageCreateFlags; > @@ -990,6 +1024,7 @@ typedef enum VkShaderStageFlagBits { > VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, > VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, > VK_SHADER_STAGE_ALL = 0x7FFFFFFF, > + VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkShaderStageFlagBits; > typedef VkFlags VkPipelineVertexInputStateCreateFlags; > typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; > @@ -1002,6 +1037,7 @@ typedef enum VkCullModeFlagBits { > VK_CULL_MODE_FRONT_BIT = 0x00000001, > VK_CULL_MODE_BACK_BIT = 0x00000002, > VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, > + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkCullModeFlagBits; > typedef VkFlags VkCullModeFlags; > typedef VkFlags VkPipelineMultisampleStateCreateFlags; > @@ -1013,6 +1049,7 @@ typedef enum VkColorComponentFlagBits { > VK_COLOR_COMPONENT_G_BIT = 0x00000002, > VK_COLOR_COMPONENT_B_BIT = 0x00000004, > VK_COLOR_COMPONENT_A_BIT = 0x00000008, > + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkColorComponentFlagBits; > typedef VkFlags VkColorComponentFlags; > typedef VkFlags VkPipelineDynamicStateCreateFlags; > @@ -1023,6 +1060,7 @@ typedef VkFlags VkDescriptorSetLayoutCreateFlags; > > typedef enum VkDescriptorPoolCreateFlagBits { > VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, > + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkDescriptorPoolCreateFlagBits; > typedef VkFlags VkDescriptorPoolCreateFlags; > typedef VkFlags VkDescriptorPoolResetFlags; > @@ -1031,6 +1069,7 @@ typedef VkFlags VkRenderPassCreateFlags; > > typedef enum VkAttachmentDescriptionFlagBits { > VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, > + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkAttachmentDescriptionFlagBits; > typedef VkFlags VkAttachmentDescriptionFlags; > typedef VkFlags VkSubpassDescriptionFlags; > @@ -1053,22 +1092,26 @@ typedef enum VkAccessFlagBits { > VK_ACCESS_HOST_WRITE_BIT = 0x00004000, > VK_ACCESS_MEMORY_READ_BIT = 0x00008000, > VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, > + VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkAccessFlagBits; > typedef VkFlags VkAccessFlags; > > typedef enum VkDependencyFlagBits { > VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, > + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkDependencyFlagBits; > typedef VkFlags VkDependencyFlags; > > typedef enum VkCommandPoolCreateFlagBits { > VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, > VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, > + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkCommandPoolCreateFlagBits; > typedef VkFlags VkCommandPoolCreateFlags; > > typedef enum VkCommandPoolResetFlagBits { > VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, > + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkCommandPoolResetFlagBits; > typedef VkFlags VkCommandPoolResetFlags; > > @@ -1076,16 +1119,19 @@ typedef enum VkCommandBufferUsageFlagBits { > VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, > VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, > VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, > + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkCommandBufferUsageFlagBits; > typedef VkFlags VkCommandBufferUsageFlags; > > typedef enum VkQueryControlFlagBits { > VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, > + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkQueryControlFlagBits; > typedef VkFlags VkQueryControlFlags; > > typedef enum VkCommandBufferResetFlagBits { > VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, > + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkCommandBufferResetFlagBits; > typedef VkFlags VkCommandBufferResetFlags; > > @@ -1093,6 +1139,7 @@ typedef enum VkStencilFaceFlagBits { > VK_STENCIL_FACE_FRONT_BIT = 0x00000001, > VK_STENCIL_FACE_BACK_BIT = 0x00000002, > VK_STENCIL_FRONT_AND_BACK = 0x00000003, > + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF > } VkStencilFaceFlagBits; > typedef VkFlags VkStencilFaceFlags; > > @@ -2320,7 +2367,7 @@ typedef void (VKAPI_PTR > *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkIm > typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, > VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, > VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* > pRegions, VkFilter filter); > typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer > commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout > dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); > typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer > commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer > dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); > -typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer > commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize > dataSize, const uint32_t* pData); > +typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer > commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize > dataSize, const void* pData); > typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, > VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); > typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer > commandBuffer, VkImage image, VkImageLayout imageLayout, const > VkClearColorValue* pColor, uint32_t rangeCount, const > VkImageSubresourceRange* pRanges); > typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer > commandBuffer, VkImage image, VkImageLayout imageLayout, const > VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const > VkImageSubresourceRange* pRanges); > @@ -3005,7 +3052,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( > VkBuffer dstBuffer, > VkDeviceSize dstOffset, > VkDeviceSize dataSize, > - const uint32_t* pData); > + const void* pData); > > VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( > VkCommandBuffer commandBuffer, > @@ -3145,14 +3192,15 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) > > #define VK_KHR_SURFACE_SPEC_VERSION 25 > #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" > +#define VK_COLORSPACE_SRGB_NONLINEAR_KHR VK_COLOR_SPACE_SRGB_NONLINEAR_KHR > > > typedef enum VkColorSpaceKHR { > - VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0, > - VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, > - VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, > - VK_COLORSPACE_RANGE_SIZE = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - > VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1), > - VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF > + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, > + VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, > + VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, > + VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - > VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1), > + VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF > } VkColorSpaceKHR; > > typedef enum VkPresentModeKHR { > @@ -3160,10 +3208,10 @@ typedef enum VkPresentModeKHR { > VK_PRESENT_MODE_MAILBOX_KHR = 1, > VK_PRESENT_MODE_FIFO_KHR = 2, > VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, > - VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR, > - VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR, > - VK_PRESENT_MODE_RANGE_SIZE = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - > VK_PRESENT_MODE_IMMEDIATE_KHR + 1), > - VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF > + VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR, > + VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR, > + VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - > VK_PRESENT_MODE_IMMEDIATE_KHR + 1), > + VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF > } VkPresentModeKHR; > > > @@ -3177,6 +3225,7 @@ typedef enum VkSurfaceTransformFlagBitsKHR { > VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, > VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, > VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, > + VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF > } VkSurfaceTransformFlagBitsKHR; > typedef VkFlags VkSurfaceTransformFlagsKHR; > > @@ -3185,6 +3234,7 @@ typedef enum VkCompositeAlphaFlagBitsKHR { > VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, > VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, > VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, > + VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF > } VkCompositeAlphaFlagBitsKHR; > typedef VkFlags VkCompositeAlphaFlagsKHR; > > @@ -3246,7 +3296,7 @@ VKAPI_ATTR VkResult VKAPI_CALL > vkGetPhysicalDeviceSurfacePresentModesKHR( > #define VK_KHR_swapchain 1 > VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) > > -#define VK_KHR_SWAPCHAIN_SPEC_VERSION 67 > +#define VK_KHR_SWAPCHAIN_SPEC_VERSION 68 > #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" > > typedef VkFlags VkSwapchainCreateFlagsKHR; > @@ -3334,6 +3384,7 @@ typedef enum VkDisplayPlaneAlphaFlagBitsKHR { > VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, > VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, > VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, > + VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF > } VkDisplayPlaneAlphaFlagBitsKHR; > typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; > typedef VkFlags VkDisplayModeCreateFlagsKHR; > @@ -3401,7 +3452,7 @@ typedef VkResult (VKAPI_PTR > *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhys > typedef VkResult (VKAPI_PTR > *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice > physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* > pProperties); > typedef VkResult (VKAPI_PTR > *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, > uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); > typedef VkResult (VKAPI_PTR > *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, > VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* > pProperties); > -typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice > physicalDevice, VkDisplayKHR display, const > VkDisplayModeCreateInfoKHR*pCreateInfo, const VkAllocationCallbacks* > pAllocator, VkDisplayModeKHR* pMode); > +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice > physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* > pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* > pMode); > typedef VkResult (VKAPI_PTR > *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, > VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* > pCapabilities); > typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance > instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const > VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); > > @@ -3684,7 +3735,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL > vkGetPhysicalDeviceWin32PresentationSupportKHR( > #define VK_EXT_debug_report 1 > VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) > > -#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 2 > +#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 3 > #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" > #define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT > VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT > > @@ -3719,11 +3770,19 @@ typedef enum VkDebugReportObjectTypeEXT { > VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, > VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, > VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, > + VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = > VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, > + VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = > VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, > + VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = > (VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT - > VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1), > + VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF > } VkDebugReportObjectTypeEXT; > > typedef enum VkDebugReportErrorEXT { > VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, > VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, > + VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_ERROR_NONE_EXT, > + VK_DEBUG_REPORT_ERROR_END_RANGE_EXT = > VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT, > + VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT = > (VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT - VK_DEBUG_REPORT_ERROR_NONE_EXT + 1), > + VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT = 0x7FFFFFFF > } VkDebugReportErrorEXT; > > > @@ -3733,6 +3792,7 @@ typedef enum VkDebugReportFlagBitsEXT { > VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, > VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, > VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, > + VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF > } VkDebugReportFlagBitsEXT; > typedef VkFlags VkDebugReportFlagsEXT; > > @@ -3793,6 +3853,307 @@ VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( > #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" > > > +#define VK_AMD_rasterization_order 1 > +#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 > +#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME > "VK_AMD_rasterization_order" > + > + > +typedef enum VkRasterizationOrderAMD { > + VK_RASTERIZATION_ORDER_STRICT_AMD = 0, > + VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, > + VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = > VK_RASTERIZATION_ORDER_STRICT_AMD, > + VK_RASTERIZATION_ORDER_END_RANGE_AMD = > VK_RASTERIZATION_ORDER_RELAXED_AMD, > + VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = > (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1), > + VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF > +} VkRasterizationOrderAMD; > + > +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { > + VkStructureType sType; > + const void* pNext; > + VkRasterizationOrderAMD rasterizationOrder; > +} VkPipelineRasterizationStateRasterizationOrderAMD; > + > + > + > +#define VK_AMD_shader_trinary_minmax 1 > +#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 > +#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME > "VK_AMD_shader_trinary_minmax" > + > + > +#define VK_AMD_shader_explicit_vertex_parameter 1 > +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 > +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME > "VK_AMD_shader_explicit_vertex_parameter" > + > + > +#define VK_EXT_debug_marker 1 > +#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 3 > +#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" > + > +typedef struct VkDebugMarkerObjectNameInfoEXT { > + VkStructureType sType; > + const void* pNext; > + VkDebugReportObjectTypeEXT objectType; > + uint64_t object; > + const char* pObjectName; > +} VkDebugMarkerObjectNameInfoEXT; > + > +typedef struct VkDebugMarkerObjectTagInfoEXT { > + VkStructureType sType; > + const void* pNext; > + VkDebugReportObjectTypeEXT objectType; > + uint64_t object; > + uint64_t tagName; > + size_t tagSize; > + const void* pTag; > +} VkDebugMarkerObjectTagInfoEXT; > + > +typedef struct VkDebugMarkerMarkerInfoEXT { > + VkStructureType sType; > + const void* pNext; > + const char* pMarkerName; > + float color[4]; > +} VkDebugMarkerMarkerInfoEXT; > + > + > +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice > device, VkDebugMarkerObjectTagInfoEXT* pTagInfo); > +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice > device, VkDebugMarkerObjectNameInfoEXT* pNameInfo); > +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer > commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo); > +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer > commandBuffer); > +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer > commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo); > + > +#ifndef VK_NO_PROTOTYPES > +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( > + VkDevice device, > + VkDebugMarkerObjectTagInfoEXT* pTagInfo); > + > +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( > + VkDevice device, > + VkDebugMarkerObjectNameInfoEXT* pNameInfo); > + > +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( > + VkCommandBuffer commandBuffer, > + VkDebugMarkerMarkerInfoEXT* pMarkerInfo); > + > +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( > + VkCommandBuffer commandBuffer); > + > +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( > + VkCommandBuffer commandBuffer, > + VkDebugMarkerMarkerInfoEXT* pMarkerInfo); > +#endif > + > +#define VK_AMD_gcn_shader 1 > +#define VK_AMD_GCN_SHADER_SPEC_VERSION 1 > +#define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" > + > + > +#define VK_NV_dedicated_allocation 1 > +#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 > +#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME > "VK_NV_dedicated_allocation" > + > +typedef struct VkDedicatedAllocationImageCreateInfoNV { > + VkStructureType sType; > + const void* pNext; > + VkBool32 dedicatedAllocation; > +} VkDedicatedAllocationImageCreateInfoNV; > + > +typedef struct VkDedicatedAllocationBufferCreateInfoNV { > + VkStructureType sType; > + const void* pNext; > + VkBool32 dedicatedAllocation; > +} VkDedicatedAllocationBufferCreateInfoNV; > + > +typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { > + VkStructureType sType; > + const void* pNext; > + VkImage image; > + VkBuffer buffer; > +} VkDedicatedAllocationMemoryAllocateInfoNV; > + > + > + > +#define VK_AMD_draw_indirect_count 1 > +#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 > +#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME > "VK_AMD_draw_indirect_count" > + > +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer > commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, > VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); > +typedef void (VKAPI_PTR > *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, > VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize > countBufferOffset, uint32_t maxDrawCount, uint32_t stride); > + > +#ifndef VK_NO_PROTOTYPES > +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( > + VkCommandBuffer commandBuffer, > + VkBuffer buffer, > + VkDeviceSize offset, > + VkBuffer countBuffer, > + VkDeviceSize countBufferOffset, > + uint32_t maxDrawCount, > + uint32_t stride); > + > +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( > + VkCommandBuffer commandBuffer, > + VkBuffer buffer, > + VkDeviceSize offset, > + VkBuffer countBuffer, > + VkDeviceSize countBufferOffset, > + uint32_t maxDrawCount, > + uint32_t stride); > +#endif > + > +#define VK_AMD_negative_viewport_height 1 > +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 > +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME > "VK_AMD_negative_viewport_height" > + > + > +#define VK_AMD_gpu_shader_half_float 1 > +#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1 > +#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME > "VK_AMD_gpu_shader_half_float" > + > + > +#define VK_AMD_shader_ballot 1 > +#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 > +#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" > + > + > +#define VK_IMG_format_pvrtc 1 > +#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 > +#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" > + > + > +#define VK_NV_external_memory_capabilities 1 > +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 > +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME > "VK_NV_external_memory_capabilities" > + > + > +typedef enum VkExternalMemoryHandleTypeFlagBitsNV { > + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, > + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, > + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, > + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, > + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF > +} VkExternalMemoryHandleTypeFlagBitsNV; > +typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; > + > +typedef enum VkExternalMemoryFeatureFlagBitsNV { > + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, > + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, > + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, > + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF > +} VkExternalMemoryFeatureFlagBitsNV; > +typedef VkFlags VkExternalMemoryFeatureFlagsNV; > + > +typedef struct VkExternalImageFormatPropertiesNV { > + VkImageFormatProperties imageFormatProperties; > + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; > + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; > + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; > +} VkExternalImageFormatPropertiesNV; > + > + > +typedef VkResult (VKAPI_PTR > *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice > physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, > VkImageUsageFlags usage, VkImageCreateFlags flags, > VkExternalMemoryHandleTypeFlagsNV externalHandleType, > VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); > + > +#ifndef VK_NO_PROTOTYPES > +VKAPI_ATTR VkResult VKAPI_CALL > vkGetPhysicalDeviceExternalImageFormatPropertiesNV( > + VkPhysicalDevice physicalDevice, > + VkFormat format, > + VkImageType type, > + VkImageTiling tiling, > + VkImageUsageFlags usage, > + VkImageCreateFlags flags, > + VkExternalMemoryHandleTypeFlagsNV externalHandleType, > + VkExternalImageFormatPropertiesNV* > pExternalImageFormatProperties); > +#endif > + > +#define VK_NV_external_memory 1 > +#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 > +#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" > + > +typedef struct VkExternalMemoryImageCreateInfoNV { > + VkStructureType sType; > + const void* pNext; > + VkExternalMemoryHandleTypeFlagsNV handleTypes; > +} VkExternalMemoryImageCreateInfoNV; > + > +typedef struct VkExportMemoryAllocateInfoNV { > + VkStructureType sType; > + const void* pNext; > + VkExternalMemoryHandleTypeFlagsNV handleTypes; > +} VkExportMemoryAllocateInfoNV; > + > + > + > +#ifdef VK_USE_PLATFORM_WIN32_KHR > +#define VK_NV_external_memory_win32 1 > +#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 > +#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME > "VK_NV_external_memory_win32" > + > +typedef struct VkImportMemoryWin32HandleInfoNV { > + VkStructureType sType; > + const void* pNext; > + VkExternalMemoryHandleTypeFlagsNV handleType; > + HANDLE handle; > +} VkImportMemoryWin32HandleInfoNV; > + > +typedef struct VkExportMemoryWin32HandleInfoNV { > + VkStructureType sType; > + const void* pNext; > + const SECURITY_ATTRIBUTES* pAttributes; > + DWORD dwAccess; > +} VkExportMemoryWin32HandleInfoNV; > + > + > +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, > VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* > pHandle); > + > +#ifndef VK_NO_PROTOTYPES > +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( > + VkDevice device, > + VkDeviceMemory memory, > + VkExternalMemoryHandleTypeFlagsNV handleType, > + HANDLE* pHandle); > +#endif > +#endif /* VK_USE_PLATFORM_WIN32_KHR */ > + > +#ifdef VK_USE_PLATFORM_WIN32_KHR > +#define VK_NV_win32_keyed_mutex 1 > +#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1 > +#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" > + > +typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { > + VkStructureType sType; > + const void* pNext; > + uint32_t acquireCount; > + const VkDeviceMemory* pAcquireSyncs; > + const uint64_t* pAcquireKeys; > + const uint32_t* pAcquireTimeoutMilliseconds; > + uint32_t releaseCount; > + const VkDeviceMemory* pReleaseSyncs; > + const uint64_t* pReleaseKeys; > +} VkWin32KeyedMutexAcquireReleaseInfoNV; > + > + > +#endif /* VK_USE_PLATFORM_WIN32_KHR */ > + > +#define VK_EXT_validation_flags 1 > +#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1 > +#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" > + > + > +typedef enum VkValidationCheckEXT { > + VK_VALIDATION_CHECK_ALL_EXT = 0, > + VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, > + VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, > + VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_ALL_EXT - > VK_VALIDATION_CHECK_ALL_EXT + 1), > + VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF > +} VkValidationCheckEXT; > + > +typedef struct VkValidationFlagsEXT { > + VkStructureType sType; > + const void* pNext; > + uint32_t disabledValidationCheckCount; > + VkValidationCheckEXT* pDisabledValidationChecks; > +} VkValidationFlagsEXT; > + > + > + > #ifdef __cplusplus > } > #endif > diff --git a/src/amd/vulkan/radv_meta_buffer.c > b/src/amd/vulkan/radv_meta_buffer.c > index 05c4971..42297b9 100644 > --- a/src/amd/vulkan/radv_meta_buffer.c > +++ b/src/amd/vulkan/radv_meta_buffer.c > @@ -511,7 +511,7 @@ void radv_CmdUpdateBuffer( > VkBuffer dstBuffer, > VkDeviceSize dstOffset, > VkDeviceSize dataSize, > - const uint32_t* pData) > + const void* pData) > { > RADV_FROM_HANDLE(radv_cmd_buffer, cmd_buffer, commandBuffer); > RADV_FROM_HANDLE(radv_buffer, dst_buffer, dstBuffer); > diff --git a/src/intel/vulkan/anv_blorp.c b/src/intel/vulkan/anv_blorp.c > index 0feb5d5..b78c21d 100644 > --- a/src/intel/vulkan/anv_blorp.c > +++ b/src/intel/vulkan/anv_blorp.c > @@ -645,7 +645,7 @@ void anv_CmdUpdateBuffer( > VkBuffer dstBuffer, > VkDeviceSize dstOffset, > VkDeviceSize dataSize, > - const uint32_t* pData) > + const void* pData) > { > ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); > ANV_FROM_HANDLE(anv_buffer, dst_buffer, dstBuffer); > -- > 2.5.5 > > _______________________________________________ > mesa-dev mailing list > mesa-dev@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/mesa-dev _______________________________________________ mesa-dev mailing list mesa-dev@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/mesa-dev
