Skip to content

S
swiftshader
Commit b461e20f by Nicolas Capens Committed by Nicolas Capens
Options

Update Vulkan headers to version 1.2.178

Includes VK_EXT_provoking_vertex definitions in vulkan_core.h, allowing to delete the custom vk_ext_provoking_vertex.h header. The include of vulkan_fuchsia_extras.h into vulkan.h was manually added back, and the definitions that are now part of vulkan_fuchsia.h were removed from vulkan_fuchsia_extras.h. https://github.com/KhronosGroup/Vulkan-Headers revision 9af411e83fb08cd2bddc3ec771de89416a96cb91 tag v1.2.178 Bug: b/142379729 Change-Id: I83a248b792149a6019fa0a14afbf790297b0e6d0 Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/54308Reviewed-by: 's avatarAlexis Hétu <sugoi@google.com> Kokoro-Result: kokoro <noreply+kokoro@google.com> Tested-by: 's avatarNicolas Capens <nicolascapens@google.com>
parent c4d054c6
Showing with 803 additions and 539 deletions
include/vulkan/vk_ext_provoking_vertex.h deleted 100644 → 0
// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
//
// 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
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 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.
#include "vulkan_core.h"
// THIS FILE SHOULD BE DELETED IF VK_EXT_provoking_vertex IS EVER ADDED TO THE VULKAN HEADERS
#ifdef VK_EXT_provoking_vertex
#error "VK_EXT_provoking_vertex is already defined in the Vulkan headers, you can delete this file"
#endif
static constexpr VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = static_cast<VkStructureType>(1000254000);
static constexpr VkStructureType VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = static_cast<VkStructureType>(1000254001);
static constexpr VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = static_cast<VkStructureType>(1000254002);
#define VK_EXT_provoking_vertex 1
#define VK_EXT_PROVOKING_VERTEX_SPEC_VERSION 1
#define VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME "VK_EXT_provoking_vertex"
typedef enum VkProvokingVertexModeEXT {
VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0,
VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1,
VK_PROVOKING_VERTEX_MODE_BEGIN_RANGE_EXT = VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT,
VK_PROVOKING_VERTEX_MODE_END_RANGE_EXT = VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT,
VK_PROVOKING_VERTEX_MODE_RANGE_SIZE_EXT = (VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT - VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT + 1),
VK_PROVOKING_VERTEX_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkProvokingVertexModeEXT;
typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT {
VkStructureType sType;
void* pNext;
VkBool32 provokingVertexLast;
} VkPhysicalDeviceProvokingVertexFeaturesEXT;
typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT {
VkStructureType sType;
void* pNext;
VkBool32 provokingVertexModePerPipeline;
} VkPhysicalDeviceProvokingVertexPropertiesEXT;
typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT {
VkStructureType sType;
const void* pNext;
VkProvokingVertexModeEXT provokingVertexMode;
} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT;
include/vulkan/vk_icd.h
...@@ -121,6 +121,8 @@ typedef enum { ...@@ -121,6 +121,8 @@ typedef enum {
VK_ICD_WSI_PLATFORM_METAL, VK_ICD_WSI_PLATFORM_METAL,
VK_ICD_WSI_PLATFORM_DIRECTFB, VK_ICD_WSI_PLATFORM_DIRECTFB,
VK_ICD_WSI_PLATFORM_VI, VK_ICD_WSI_PLATFORM_VI,
VK_ICD_WSI_PLATFORM_GGP,
VK_ICD_WSI_PLATFORM_SCREEN,
} VkIcdWsiPlatform; } VkIcdWsiPlatform;
typedef struct { typedef struct {
...@@ -196,6 +198,13 @@ typedef struct { ...@@ -196,6 +198,13 @@ typedef struct {
} VkIcdSurfaceIOS; } VkIcdSurfaceIOS;
#endif // VK_USE_PLATFORM_IOS_MVK #endif // VK_USE_PLATFORM_IOS_MVK
#ifdef VK_USE_PLATFORM_GGP
typedef struct {
VkIcdSurfaceBase base;
GgpStreamDescriptor streamDescriptor;
} VkIcdSurfaceGgp;
#endif // VK_USE_PLATFORM_GGP
typedef struct { typedef struct {
VkIcdSurfaceBase base; VkIcdSurfaceBase base;
VkDisplayModeKHR displayMode; VkDisplayModeKHR displayMode;
...@@ -225,4 +234,12 @@ typedef struct { ...@@ -225,4 +234,12 @@ typedef struct {
} VkIcdSurfaceVi; } VkIcdSurfaceVi;
#endif // VK_USE_PLATFORM_VI_NN #endif // VK_USE_PLATFORM_VI_NN
#ifdef VK_USE_PLATFORM_SCREEN_QNX
typedef struct {
VkIcdSurfaceBase base;
struct _screen_context *context;
struct _screen_window *window;
} VkIcdSurfaceScreen;
#endif // VK_USE_PLATFORM_SCREEN_QNX
#endif // VKICD_H #endif // VKICD_H
include/vulkan/vk_platform.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
// File: vk_platform.h // File: vk_platform.h
// //
/* /*
** Copyright (c) 2014-2020 The Khronos Group Inc. ** Copyright 2014-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
...@@ -58,7 +58,9 @@ extern "C" ...@@ -58,7 +58,9 @@ extern "C"
#define VKAPI_PTR #define VKAPI_PTR
#endif #endif
#include <stddef.h> #if !defined(VK_NO_STDDEF_H)
#include <stddef.h>
#endif // !defined(VK_NO_STDDEF_H)
#if !defined(VK_NO_STDINT_H) #if !defined(VK_NO_STDINT_H)
#if defined(_MSC_VER) && (_MSC_VER < 1600) #if defined(_MSC_VER) && (_MSC_VER < 1600)
......
include/vulkan/vulkan.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_H_ 1 #define VULKAN_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
...@@ -81,6 +81,12 @@ ...@@ -81,6 +81,12 @@
#endif #endif
#ifdef VK_USE_PLATFORM_SCREEN_QNX
#include <screen/screen.h>
#include "vulkan_screen.h"
#endif
#ifdef VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS
#include "vulkan_beta.h" #include "vulkan_beta.h"
#endif #endif
......
include/vulkan/vulkan.hpp
This source diff could not be displayed because it is too large. You can view the blob instead.
include/vulkan/vulkan_android.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_ANDROID_H_ 1 #define VULKAN_ANDROID_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
include/vulkan/vulkan_beta.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_BETA_H_ 1 #define VULKAN_BETA_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
...@@ -19,6 +19,325 @@ extern "C" { ...@@ -19,6 +19,325 @@ extern "C" {
#define VK_KHR_video_queue 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR)
#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION 1
#define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue"
typedef enum VkQueryResultStatusKHR {
VK_QUERY_RESULT_STATUS_ERROR_KHR = -1,
VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0,
VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1,
VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkQueryResultStatusKHR;
typedef enum VkVideoCodecOperationFlagBitsKHR {
VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR = 0,
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000,
#endif
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT = 0x00000001,
#endif
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT = 0x00000002,
#endif
VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkVideoCodecOperationFlagBitsKHR;
typedef VkFlags VkVideoCodecOperationFlagsKHR;
typedef enum VkVideoChromaSubsamplingFlagBitsKHR {
VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_BIT_KHR = 0,
VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001,
VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002,
VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004,
VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008,
VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkVideoChromaSubsamplingFlagBitsKHR;
typedef VkFlags VkVideoChromaSubsamplingFlagsKHR;
typedef enum VkVideoComponentBitDepthFlagBitsKHR {
VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0,
VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001,
VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004,
VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010,
VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkVideoComponentBitDepthFlagBitsKHR;
typedef VkFlags VkVideoComponentBitDepthFlagsKHR;
typedef enum VkVideoCapabilitiesFlagBitsKHR {
VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR = 0x00000001,
VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002,
VK_VIDEO_CAPABILITIES_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkVideoCapabilitiesFlagBitsKHR;
typedef VkFlags VkVideoCapabilitiesFlagsKHR;
typedef enum VkVideoSessionCreateFlagBitsKHR {
VK_VIDEO_SESSION_CREATE_DEFAULT_KHR = 0,
VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001,
VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkVideoSessionCreateFlagBitsKHR;
typedef VkFlags VkVideoSessionCreateFlagsKHR;
typedef VkFlags VkVideoBeginCodingFlagsKHR;
typedef VkFlags VkVideoEndCodingFlagsKHR;
typedef enum VkVideoCodingControlFlagBitsKHR {
VK_VIDEO_CODING_CONTROL_DEFAULT_KHR = 0,
VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001,
VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkVideoCodingControlFlagBitsKHR;
typedef VkFlags VkVideoCodingControlFlagsKHR;
typedef enum VkVideoCodingQualityPresetFlagBitsKHR {
VK_VIDEO_CODING_QUALITY_PRESET_DEFAULT_BIT_KHR = 0,
VK_VIDEO_CODING_QUALITY_PRESET_NORMAL_BIT_KHR = 0x00000001,
VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR = 0x00000002,
VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR = 0x00000004,
VK_VIDEO_CODING_QUALITY_PRESET_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkVideoCodingQualityPresetFlagBitsKHR;
typedef VkFlags VkVideoCodingQualityPresetFlagsKHR;
typedef struct VkVideoQueueFamilyProperties2KHR {
VkStructureType sType;
void* pNext;
VkVideoCodecOperationFlagsKHR videoCodecOperations;
} VkVideoQueueFamilyProperties2KHR;
typedef struct VkVideoProfileKHR {
VkStructureType sType;
void* pNext;
VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
} VkVideoProfileKHR;
typedef struct VkVideoProfilesKHR {
VkStructureType sType;
void* pNext;
uint32_t profileCount;
const VkVideoProfileKHR* pProfiles;
} VkVideoProfilesKHR;
typedef struct VkVideoCapabilitiesKHR {
VkStructureType sType;
void* pNext;
VkVideoCapabilitiesFlagsKHR capabilityFlags;
VkDeviceSize minBitstreamBufferOffsetAlignment;
VkDeviceSize minBitstreamBufferSizeAlignment;
VkExtent2D videoPictureExtentGranularity;
VkExtent2D minExtent;
VkExtent2D maxExtent;
uint32_t maxReferencePicturesSlotsCount;
uint32_t maxReferencePicturesActiveCount;
} VkVideoCapabilitiesKHR;
typedef struct VkPhysicalDeviceVideoFormatInfoKHR {
VkStructureType sType;
const void* pNext;
VkImageUsageFlags imageUsage;
const VkVideoProfilesKHR* pVideoProfiles;
} VkPhysicalDeviceVideoFormatInfoKHR;
typedef struct VkVideoFormatPropertiesKHR {
VkStructureType sType;
void* pNext;
VkFormat format;
} VkVideoFormatPropertiesKHR;
typedef struct VkVideoPictureResourceKHR {
VkStructureType sType;
const void* pNext;
VkOffset2D codedOffset;
VkExtent2D codedExtent;
uint32_t baseArrayLayer;
VkImageView imageViewBinding;
} VkVideoPictureResourceKHR;
typedef struct VkVideoReferenceSlotKHR {
VkStructureType sType;
const void* pNext;
int8_t slotIndex;
const VkVideoPictureResourceKHR* pPictureResource;
} VkVideoReferenceSlotKHR;
typedef struct VkVideoGetMemoryPropertiesKHR {
VkStructureType sType;
const void* pNext;
uint32_t memoryBindIndex;
VkMemoryRequirements2* pMemoryRequirements;
} VkVideoGetMemoryPropertiesKHR;
typedef struct VkVideoBindMemoryKHR {
VkStructureType sType;
const void* pNext;
uint32_t memoryBindIndex;
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
VkDeviceSize memorySize;
} VkVideoBindMemoryKHR;
typedef struct VkVideoSessionCreateInfoKHR {
VkStructureType sType;
const void* pNext;
uint32_t queueFamilyIndex;
VkVideoSessionCreateFlagsKHR flags;
const VkVideoProfileKHR* pVideoProfile;
VkFormat pictureFormat;
VkExtent2D maxCodedExtent;
VkFormat referencePicturesFormat;
uint32_t maxReferencePicturesSlotsCount;
uint32_t maxReferencePicturesActiveCount;
} VkVideoSessionCreateInfoKHR;
typedef struct VkVideoSessionParametersCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkVideoSessionParametersKHR videoSessionParametersTemplate;
VkVideoSessionKHR videoSession;
} VkVideoSessionParametersCreateInfoKHR;
typedef struct VkVideoSessionParametersUpdateInfoKHR {
VkStructureType sType;
const void* pNext;
uint32_t updateSequenceCount;
} VkVideoSessionParametersUpdateInfoKHR;
typedef struct VkVideoBeginCodingInfoKHR {
VkStructureType sType;
const void* pNext;
VkVideoBeginCodingFlagsKHR flags;
VkVideoCodingQualityPresetFlagsKHR codecQualityPreset;
VkVideoSessionKHR videoSession;
VkVideoSessionParametersKHR videoSessionParameters;
uint32_t referenceSlotCount;
const VkVideoReferenceSlotKHR* pReferenceSlots;
} VkVideoBeginCodingInfoKHR;
typedef struct VkVideoEndCodingInfoKHR {
VkStructureType sType;
const void* pNext;
VkVideoEndCodingFlagsKHR flags;
} VkVideoEndCodingInfoKHR;
typedef struct VkVideoCodingControlInfoKHR {
VkStructureType sType;
const void* pNext;
VkVideoCodingControlFlagsKHR flags;
} VkVideoCodingControlInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities);
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties);
typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession);
typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator);
typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements);
typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories);
typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters);
typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo);
typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator);
typedef void (VKAPI_PTR *PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo);
typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo);
typedef void (VKAPI_PTR *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
const VkVideoProfileKHR* pVideoProfile,
VkVideoCapabilitiesKHR* pCapabilities);
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
uint32_t* pVideoFormatPropertyCount,
VkVideoFormatPropertiesKHR* pVideoFormatProperties);
VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR(
VkDevice device,
const VkVideoSessionCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkVideoSessionKHR* pVideoSession);
VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR(
VkDevice device,
VkVideoSessionKHR videoSession,
const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(
VkDevice device,
VkVideoSessionKHR videoSession,
uint32_t* pVideoSessionMemoryRequirementsCount,
VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements);
VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(
VkDevice device,
VkVideoSessionKHR videoSession,
uint32_t videoSessionBindMemoryCount,
const VkVideoBindMemoryKHR* pVideoSessionBindMemories);
VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR(
VkDevice device,
const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkVideoSessionParametersKHR* pVideoSessionParameters);
VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(
VkDevice device,
VkVideoSessionParametersKHR videoSessionParameters,
const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo);
VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR(
VkDevice device,
VkVideoSessionParametersKHR videoSessionParameters,
const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR(
VkCommandBuffer commandBuffer,
const VkVideoBeginCodingInfoKHR* pBeginInfo);
VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR(
VkCommandBuffer commandBuffer,
const VkVideoEndCodingInfoKHR* pEndCodingInfo);
VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(
VkCommandBuffer commandBuffer,
const VkVideoCodingControlInfoKHR* pCodingControlInfo);
#endif
#define VK_KHR_video_decode_queue 1
#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 1
#define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue"
typedef enum VkVideoDecodeFlagBitsKHR {
VK_VIDEO_DECODE_DEFAULT_KHR = 0,
VK_VIDEO_DECODE_RESERVED_0_BIT_KHR = 0x00000001,
VK_VIDEO_DECODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkVideoDecodeFlagBitsKHR;
typedef VkFlags VkVideoDecodeFlagsKHR;
typedef struct VkVideoDecodeInfoKHR {
VkStructureType sType;
const void* pNext;
VkVideoDecodeFlagsKHR flags;
VkOffset2D codedOffset;
VkExtent2D codedExtent;
VkBuffer srcBuffer;
VkDeviceSize srcBufferOffset;
VkDeviceSize srcBufferRange;
VkVideoPictureResourceKHR dstPictureResource;
const VkVideoReferenceSlotKHR* pSetupReferenceSlot;
uint32_t referenceSlotCount;
const VkVideoReferenceSlotKHR* pReferenceSlots;
} VkVideoDecodeInfoKHR;
typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR(
VkCommandBuffer commandBuffer,
const VkVideoDecodeInfoKHR* pFrameInfo);
#endif
#define VK_KHR_portability_subset 1 #define VK_KHR_portability_subset 1
#define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1 #define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1
#define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset" #define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset"
...@@ -50,407 +369,333 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR { ...@@ -50,407 +369,333 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
#define VK_KHR_deferred_host_operations 1 #define VK_KHR_video_encode_queue 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR) #define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 2
#define VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION 3 #define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue"
#define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations"
typedef struct VkDeferredOperationInfoKHR { typedef enum VkVideoEncodeFlagBitsKHR {
VkStructureType sType; VK_VIDEO_ENCODE_DEFAULT_KHR = 0,
const void* pNext; VK_VIDEO_ENCODE_RESERVED_0_BIT_KHR = 0x00000001,
VkDeferredOperationKHR operationHandle; VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkDeferredOperationInfoKHR; } VkVideoEncodeFlagBitsKHR;
typedef VkFlags VkVideoEncodeFlagsKHR;
typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation);
typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator); typedef enum VkVideoEncodeRateControlFlagBitsKHR {
typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation); VK_VIDEO_ENCODE_RATE_CONTROL_DEFAULT_KHR = 0,
typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation); VK_VIDEO_ENCODE_RATE_CONTROL_RESET_BIT_KHR = 0x00000001,
typedef VkResult (VKAPI_PTR *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation); VK_VIDEO_ENCODE_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkVideoEncodeRateControlFlagBitsKHR;
typedef VkFlags VkVideoEncodeRateControlFlagsKHR;
typedef enum VkVideoEncodeRateControlModeFlagBitsKHR {
VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR = 0,
VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 1,
VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 2,
VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkVideoEncodeRateControlModeFlagBitsKHR;
typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR;
typedef struct VkVideoEncodeInfoKHR {
VkStructureType sType;
const void* pNext;
VkVideoEncodeFlagsKHR flags;
uint32_t qualityLevel;
VkExtent2D codedExtent;
VkBuffer dstBitstreamBuffer;
VkDeviceSize dstBitstreamBufferOffset;
VkDeviceSize dstBitstreamBufferMaxRange;
VkVideoPictureResourceKHR srcPictureResource;
const VkVideoReferenceSlotKHR* pSetupReferenceSlot;
uint32_t referenceSlotCount;
const VkVideoReferenceSlotKHR* pReferenceSlots;
} VkVideoEncodeInfoKHR;
typedef struct VkVideoEncodeRateControlInfoKHR {
VkStructureType sType;
const void* pNext;
VkVideoEncodeRateControlFlagsKHR flags;
VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode;
uint32_t averageBitrate;
uint16_t peakToAverageBitrateRatio;
uint16_t frameRateNumerator;
uint16_t frameRateDenominator;
uint32_t virtualBufferSizeInMs;
} VkVideoEncodeRateControlInfoKHR;
typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR( VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(
VkDevice device, VkCommandBuffer commandBuffer,
const VkAllocationCallbacks* pAllocator, const VkVideoEncodeInfoKHR* pEncodeInfo);
VkDeferredOperationKHR* pDeferredOperation);
VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR(
VkDevice device,
VkDeferredOperationKHR operation,
const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(
VkDevice device,
VkDeferredOperationKHR operation);
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(
VkDevice device,
VkDeferredOperationKHR operation);
VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(
VkDevice device,
VkDeferredOperationKHR operation);
#endif #endif
#define VK_KHR_pipeline_library 1 #define VK_EXT_video_encode_h264 1
#define VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION 1 #include "vk_video/vulkan_video_codec_h264std.h"
#define VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME "VK_KHR_pipeline_library" #include "vk_video/vulkan_video_codec_h264std_encode.h"
typedef struct VkPipelineLibraryCreateInfoKHR { #define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 1
VkStructureType sType; #define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"
const void* pNext;
uint32_t libraryCount; typedef enum VkVideoEncodeH264CapabilitiesFlagBitsEXT {
const VkPipeline* pLibraries; VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00000001,
} VkPipelineLibraryCreateInfoKHR; VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00000002,
VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT = 0x00000004,
VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0x00000008,
VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0x00000010,
#define VK_KHR_ray_tracing 1 VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0x00000020,
#define VK_KHR_RAY_TRACING_SPEC_VERSION 8 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00000040,
#define VK_KHR_RAY_TRACING_EXTENSION_NAME "VK_KHR_ray_tracing" VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00000080,
VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00000100,
typedef enum VkAccelerationStructureBuildTypeKHR { VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00000200,
VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0, VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT = 0x00000400,
VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1, VK_VIDEO_ENCODE_H264_CAPABILITIES_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2, } VkVideoEncodeH264CapabilitiesFlagBitsEXT;
VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF typedef VkFlags VkVideoEncodeH264CapabilitiesFlagsEXT;
} VkAccelerationStructureBuildTypeKHR;
typedef union VkDeviceOrHostAddressKHR { typedef enum VkVideoEncodeH264InputModeFlagBitsEXT {
VkDeviceAddress deviceAddress; VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0x00000001,
void* hostAddress; VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT = 0x00000002,
} VkDeviceOrHostAddressKHR; VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,
VK_VIDEO_ENCODE_H264_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
typedef union VkDeviceOrHostAddressConstKHR { } VkVideoEncodeH264InputModeFlagBitsEXT;
VkDeviceAddress deviceAddress; typedef VkFlags VkVideoEncodeH264InputModeFlagsEXT;
const void* hostAddress;
} VkDeviceOrHostAddressConstKHR; typedef enum VkVideoEncodeH264OutputModeFlagBitsEXT {
VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT = 0x00000001,
typedef struct VkAccelerationStructureBuildOffsetInfoKHR { VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT = 0x00000002,
uint32_t primitiveCount; VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT = 0x00000004,
uint32_t primitiveOffset; VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
uint32_t firstVertex; } VkVideoEncodeH264OutputModeFlagBitsEXT;
uint32_t transformOffset; typedef VkFlags VkVideoEncodeH264OutputModeFlagsEXT;
} VkAccelerationStructureBuildOffsetInfoKHR;
typedef enum VkVideoEncodeH264CreateFlagBitsEXT {
typedef struct VkRayTracingShaderGroupCreateInfoKHR { VK_VIDEO_ENCODE_H264_CREATE_DEFAULT_EXT = 0,
VkStructureType sType; VK_VIDEO_ENCODE_H264_CREATE_RESERVED_0_BIT_EXT = 0x00000001,
const void* pNext; VK_VIDEO_ENCODE_H264_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
VkRayTracingShaderGroupTypeKHR type; } VkVideoEncodeH264CreateFlagBitsEXT;
uint32_t generalShader; typedef VkFlags VkVideoEncodeH264CreateFlagsEXT;
uint32_t closestHitShader; typedef struct VkVideoEncodeH264CapabilitiesEXT {
uint32_t anyHitShader; VkStructureType sType;
uint32_t intersectionShader; const void* pNext;
const void* pShaderGroupCaptureReplayHandle; VkVideoEncodeH264CapabilitiesFlagsEXT flags;
} VkRayTracingShaderGroupCreateInfoKHR; VkVideoEncodeH264InputModeFlagsEXT inputModeFlags;
VkVideoEncodeH264OutputModeFlagsEXT outputModeFlags;
typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR { VkExtent2D minPictureSizeInMbs;
VkStructureType sType; VkExtent2D maxPictureSizeInMbs;
const void* pNext; VkExtent2D inputImageDataAlignment;
uint32_t maxPayloadSize; uint8_t maxNumL0ReferenceForP;
uint32_t maxAttributeSize; uint8_t maxNumL0ReferenceForB;
uint32_t maxCallableSize; uint8_t maxNumL1Reference;
} VkRayTracingPipelineInterfaceCreateInfoKHR; uint8_t qualityLevelCount;
VkExtensionProperties stdExtensionVersion;
typedef struct VkRayTracingPipelineCreateInfoKHR { } VkVideoEncodeH264CapabilitiesEXT;
VkStructureType sType;
const void* pNext; typedef struct VkVideoEncodeH264SessionCreateInfoEXT {
VkPipelineCreateFlags flags; VkStructureType sType;
uint32_t stageCount; const void* pNext;
const VkPipelineShaderStageCreateInfo* pStages; VkVideoEncodeH264CreateFlagsEXT flags;
uint32_t groupCount; VkExtent2D maxPictureSizeInMbs;
const VkRayTracingShaderGroupCreateInfoKHR* pGroups; const VkExtensionProperties* pStdExtensionVersion;
uint32_t maxRecursionDepth; } VkVideoEncodeH264SessionCreateInfoEXT;
VkPipelineLibraryCreateInfoKHR libraries;
const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface; typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT {
VkPipelineLayout layout; VkStructureType sType;
VkPipeline basePipelineHandle; const void* pNext;
int32_t basePipelineIndex; uint32_t spsStdCount;
} VkRayTracingPipelineCreateInfoKHR; const StdVideoH264SequenceParameterSet* pSpsStd;
uint32_t ppsStdCount;
typedef struct VkAccelerationStructureGeometryTrianglesDataKHR { const StdVideoH264PictureParameterSet* pPpsStd;
VkStructureType sType; } VkVideoEncodeH264SessionParametersAddInfoEXT;
const void* pNext;
VkFormat vertexFormat; typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT {
VkDeviceOrHostAddressConstKHR vertexData; VkStructureType sType;
VkDeviceSize vertexStride; const void* pNext;
VkIndexType indexType; uint32_t maxSpsStdCount;
VkDeviceOrHostAddressConstKHR indexData; uint32_t maxPpsStdCount;
VkDeviceOrHostAddressConstKHR transformData; const VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo;
} VkAccelerationStructureGeometryTrianglesDataKHR; } VkVideoEncodeH264SessionParametersCreateInfoEXT;
typedef struct VkAccelerationStructureGeometryAabbsDataKHR { typedef struct VkVideoEncodeH264DpbSlotInfoEXT {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkDeviceOrHostAddressConstKHR data; int8_t slotIndex;
VkDeviceSize stride; const StdVideoEncodeH264PictureInfo* pStdPictureInfo;
} VkAccelerationStructureGeometryAabbsDataKHR; } VkVideoEncodeH264DpbSlotInfoEXT;
typedef struct VkAccelerationStructureGeometryInstancesDataKHR { typedef struct VkVideoEncodeH264NaluSliceEXT {
VkStructureType sType;
const void* pNext;
VkBool32 arrayOfPointers;
VkDeviceOrHostAddressConstKHR data;
} VkAccelerationStructureGeometryInstancesDataKHR;
typedef union VkAccelerationStructureGeometryDataKHR {
VkAccelerationStructureGeometryTrianglesDataKHR triangles;
VkAccelerationStructureGeometryAabbsDataKHR aabbs;
VkAccelerationStructureGeometryInstancesDataKHR instances;
} VkAccelerationStructureGeometryDataKHR;
typedef struct VkAccelerationStructureGeometryKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkGeometryTypeKHR geometryType; const StdVideoEncodeH264SliceHeader* pSliceHeaderStd;
VkAccelerationStructureGeometryDataKHR geometry; uint32_t mbCount;
VkGeometryFlagsKHR flags; uint8_t refFinalList0EntryCount;
} VkAccelerationStructureGeometryKHR; const VkVideoEncodeH264DpbSlotInfoEXT* pRefFinalList0Entries;
uint8_t refFinalList1EntryCount;
typedef struct VkAccelerationStructureBuildGeometryInfoKHR { const VkVideoEncodeH264DpbSlotInfoEXT* pRefFinalList1Entries;
VkStructureType sType; uint32_t precedingNaluBytes;
const void* pNext; uint8_t minQp;
VkAccelerationStructureTypeKHR type; uint8_t maxQp;
VkBuildAccelerationStructureFlagsKHR flags; } VkVideoEncodeH264NaluSliceEXT;
VkBool32 update;
VkAccelerationStructureKHR srcAccelerationStructure; typedef struct VkVideoEncodeH264VclFrameInfoEXT {
VkAccelerationStructureKHR dstAccelerationStructure; VkStructureType sType;
VkBool32 geometryArrayOfPointers; const void* pNext;
uint32_t geometryCount; uint8_t refDefaultFinalList0EntryCount;
const VkAccelerationStructureGeometryKHR* const* ppGeometries; const VkVideoEncodeH264DpbSlotInfoEXT* pRefDefaultFinalList0Entries;
VkDeviceOrHostAddressKHR scratchData; uint8_t refDefaultFinalList1EntryCount;
} VkAccelerationStructureBuildGeometryInfoKHR; const VkVideoEncodeH264DpbSlotInfoEXT* pRefDefaultFinalList1Entries;
uint32_t naluSliceEntryCount;
typedef struct VkAccelerationStructureCreateGeometryTypeInfoKHR { const VkVideoEncodeH264NaluSliceEXT* pNaluSliceEntries;
VkStructureType sType; const VkVideoEncodeH264DpbSlotInfoEXT* pCurrentPictureInfo;
const void* pNext; } VkVideoEncodeH264VclFrameInfoEXT;
VkGeometryTypeKHR geometryType;
uint32_t maxPrimitiveCount; typedef struct VkVideoEncodeH264EmitPictureParametersEXT {
VkIndexType indexType;
uint32_t maxVertexCount;
VkFormat vertexFormat;
VkBool32 allowsTransforms;
} VkAccelerationStructureCreateGeometryTypeInfoKHR;
typedef struct VkAccelerationStructureCreateInfoKHR {
VkStructureType sType;
const void* pNext;
VkDeviceSize compactedSize;
VkAccelerationStructureTypeKHR type;
VkBuildAccelerationStructureFlagsKHR flags;
uint32_t maxGeometryCount;
const VkAccelerationStructureCreateGeometryTypeInfoKHR* pGeometryInfos;
VkDeviceAddress deviceAddress;
} VkAccelerationStructureCreateInfoKHR;
typedef struct VkAccelerationStructureMemoryRequirementsInfoKHR {
VkStructureType sType;
const void* pNext;
VkAccelerationStructureMemoryRequirementsTypeKHR type;
VkAccelerationStructureBuildTypeKHR buildType;
VkAccelerationStructureKHR accelerationStructure;
} VkAccelerationStructureMemoryRequirementsInfoKHR;
typedef struct VkPhysicalDeviceRayTracingFeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 rayTracing;
VkBool32 rayTracingShaderGroupHandleCaptureReplay;
VkBool32 rayTracingShaderGroupHandleCaptureReplayMixed;
VkBool32 rayTracingAccelerationStructureCaptureReplay;
VkBool32 rayTracingIndirectTraceRays;
VkBool32 rayTracingIndirectAccelerationStructureBuild;
VkBool32 rayTracingHostAccelerationStructureCommands;
VkBool32 rayQuery;
VkBool32 rayTracingPrimitiveCulling;
} VkPhysicalDeviceRayTracingFeaturesKHR;
typedef struct VkPhysicalDeviceRayTracingPropertiesKHR {
VkStructureType sType;
void* pNext;
uint32_t shaderGroupHandleSize;
uint32_t maxRecursionDepth;
uint32_t maxShaderGroupStride;
uint32_t shaderGroupBaseAlignment;
uint64_t maxGeometryCount;
uint64_t maxInstanceCount;
uint64_t maxPrimitiveCount;
uint32_t maxDescriptorSetAccelerationStructures;
uint32_t shaderGroupHandleCaptureReplaySize;
} VkPhysicalDeviceRayTracingPropertiesKHR;
typedef struct VkAccelerationStructureDeviceAddressInfoKHR {
VkStructureType sType;
const void* pNext;
VkAccelerationStructureKHR accelerationStructure;
} VkAccelerationStructureDeviceAddressInfoKHR;
typedef struct VkAccelerationStructureVersionKHR {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
const uint8_t* versionData; uint8_t spsId;
} VkAccelerationStructureVersionKHR; VkBool32 emitSpsEnable;
uint32_t ppsIdEntryCount;
typedef struct VkStridedBufferRegionKHR { const uint8_t* ppsIdEntries;
VkBuffer buffer; } VkVideoEncodeH264EmitPictureParametersEXT;
VkDeviceSize offset;
VkDeviceSize stride;
VkDeviceSize size;
} VkStridedBufferRegionKHR;
typedef struct VkTraceRaysIndirectCommandKHR {
uint32_t width;
uint32_t height;
uint32_t depth;
} VkTraceRaysIndirectCommandKHR;
typedef struct VkCopyAccelerationStructureToMemoryInfoKHR {
VkStructureType sType;
const void* pNext;
VkAccelerationStructureKHR src;
VkDeviceOrHostAddressKHR dst;
VkCopyAccelerationStructureModeKHR mode;
} VkCopyAccelerationStructureToMemoryInfoKHR;
typedef struct VkCopyMemoryToAccelerationStructureInfoKHR { typedef struct VkVideoEncodeH264ProfileEXT {
VkStructureType sType; VkStructureType sType;
const void* pNext; const void* pNext;
VkDeviceOrHostAddressConstKHR src; StdVideoH264ProfileIdc stdProfileIdc;
VkAccelerationStructureKHR dst; } VkVideoEncodeH264ProfileEXT;
VkCopyAccelerationStructureModeKHR mode;
} VkCopyMemoryToAccelerationStructureInfoKHR;
typedef struct VkCopyAccelerationStructureInfoKHR { #define VK_EXT_video_decode_h264 1
VkStructureType sType; #include "vk_video/vulkan_video_codec_h264std_decode.h"
const void* pNext; #define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 1
VkAccelerationStructureKHR src; #define VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME "VK_EXT_video_decode_h264"
VkAccelerationStructureKHR dst;
VkCopyAccelerationStructureModeKHR mode; typedef enum VkVideoDecodeH264FieldLayoutFlagBitsEXT {
} VkCopyAccelerationStructureInfoKHR; VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT = 0,
VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT = 0x00000001,
typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT = 0x00000002,
typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsKHR)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoKHR* pInfo, VkMemoryRequirements2* pMemoryRequirements); VK_VIDEO_DECODE_H264_FIELD_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildOffsetInfoKHR* const* ppOffsetInfos); } VkVideoDecodeH264FieldLayoutFlagBitsEXT;
typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureIndirectKHR)(VkCommandBuffer commandBuffer, const VkAccelerationStructureBuildGeometryInfoKHR* pInfo, VkBuffer indirectBuffer, VkDeviceSize indirectOffset, uint32_t indirectStride); typedef VkFlags VkVideoDecodeH264FieldLayoutFlagsEXT;
typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructureKHR)(VkDevice device, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildOffsetInfoKHR* const* ppOffsetInfos); typedef VkFlags VkVideoDecodeH264CreateFlagsEXT;
typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, const VkCopyAccelerationStructureInfoKHR* pInfo); typedef struct VkVideoDecodeH264ProfileEXT {
typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); VkStructureType sType;
typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); const void* pNext;
typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); StdVideoH264ProfileIdc stdProfileIdc;
typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo); VkVideoDecodeH264FieldLayoutFlagsEXT fieldLayout;
typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); } VkVideoDecodeH264ProfileEXT;
typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedBufferRegionKHR* pRaygenShaderBindingTable, const VkStridedBufferRegionKHR* pMissShaderBindingTable, const VkStridedBufferRegionKHR* pHitShaderBindingTable, const VkStridedBufferRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth); typedef struct VkVideoDecodeH264CapabilitiesEXT {
typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); VkStructureType sType;
typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); void* pNext;
typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); uint32_t maxLevel;
typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedBufferRegionKHR* pRaygenShaderBindingTable, const VkStridedBufferRegionKHR* pMissShaderBindingTable, const VkStridedBufferRegionKHR* pHitShaderBindingTable, const VkStridedBufferRegionKHR* pCallableShaderBindingTable, VkBuffer buffer, VkDeviceSize offset); VkOffset2D fieldOffsetGranularity;
typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionKHR* version); VkExtensionProperties stdExtensionVersion;
} VkVideoDecodeH264CapabilitiesEXT;
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR( typedef struct VkVideoDecodeH264SessionCreateInfoEXT {
VkDevice device, VkStructureType sType;
const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const void* pNext;
const VkAllocationCallbacks* pAllocator, VkVideoDecodeH264CreateFlagsEXT flags;
VkAccelerationStructureKHR* pAccelerationStructure); const VkExtensionProperties* pStdExtensionVersion;
} VkVideoDecodeH264SessionCreateInfoEXT;
VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsKHR(
VkDevice device, typedef struct VkVideoDecodeH264SessionParametersAddInfoEXT {
const VkAccelerationStructureMemoryRequirementsInfoKHR* pInfo, VkStructureType sType;
VkMemoryRequirements2* pMemoryRequirements); const void* pNext;
uint32_t spsStdCount;
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureKHR( const StdVideoH264SequenceParameterSet* pSpsStd;
VkCommandBuffer commandBuffer, uint32_t ppsStdCount;
uint32_t infoCount, const StdVideoH264PictureParameterSet* pPpsStd;
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, } VkVideoDecodeH264SessionParametersAddInfoEXT;
const VkAccelerationStructureBuildOffsetInfoKHR* const* ppOffsetInfos);
typedef struct VkVideoDecodeH264SessionParametersCreateInfoEXT {
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureIndirectKHR( VkStructureType sType;
VkCommandBuffer commandBuffer, const void* pNext;
const VkAccelerationStructureBuildGeometryInfoKHR* pInfo, uint32_t maxSpsStdCount;
VkBuffer indirectBuffer, uint32_t maxPpsStdCount;
VkDeviceSize indirectOffset, const VkVideoDecodeH264SessionParametersAddInfoEXT* pParametersAddInfo;
uint32_t indirectStride); } VkVideoDecodeH264SessionParametersCreateInfoEXT;
VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructureKHR( typedef struct VkVideoDecodeH264PictureInfoEXT {
VkDevice device, VkStructureType sType;
uint32_t infoCount, const void* pNext;
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const StdVideoDecodeH264PictureInfo* pStdPictureInfo;
const VkAccelerationStructureBuildOffsetInfoKHR* const* ppOffsetInfos); uint32_t slicesCount;
const uint32_t* pSlicesDataOffsets;
VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR( } VkVideoDecodeH264PictureInfoEXT;
VkDevice device,
const VkCopyAccelerationStructureInfoKHR* pInfo); typedef struct VkVideoDecodeH264MvcEXT {
VkStructureType sType;
VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR( const void* pNext;
VkDevice device, const StdVideoDecodeH264Mvc* pStdMvc;
const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); } VkVideoDecodeH264MvcEXT;
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR( typedef struct VkVideoDecodeH264DpbSlotInfoEXT {
VkDevice device, VkStructureType sType;
const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); const void* pNext;
const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo;
VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR( } VkVideoDecodeH264DpbSlotInfoEXT;
VkDevice device,
uint32_t accelerationStructureCount,
const VkAccelerationStructureKHR* pAccelerationStructures,
VkQueryType queryType,
size_t dataSize,
void* pData,
size_t stride);
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(
VkCommandBuffer commandBuffer,
const VkCopyAccelerationStructureInfoKHR* pInfo);
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(
VkCommandBuffer commandBuffer,
const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(
VkCommandBuffer commandBuffer,
const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(
VkCommandBuffer commandBuffer,
const VkStridedBufferRegionKHR* pRaygenShaderBindingTable,
const VkStridedBufferRegionKHR* pMissShaderBindingTable,
const VkStridedBufferRegionKHR* pHitShaderBindingTable,
const VkStridedBufferRegionKHR* pCallableShaderBindingTable,
uint32_t width,
uint32_t height,
uint32_t depth);
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines);
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR( #define VK_EXT_video_decode_h265 1
VkDevice device, #include "vk_video/vulkan_video_codec_h265std.h"
const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); #include "vk_video/vulkan_video_codec_h265std_decode.h"
#define VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION 1
#define VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME "VK_EXT_video_decode_h265"
typedef VkFlags VkVideoDecodeH265CreateFlagsEXT;
typedef struct VkVideoDecodeH265ProfileEXT {
VkStructureType sType;
const void* pNext;
StdVideoH265ProfileIdc stdProfileIdc;
} VkVideoDecodeH265ProfileEXT;
typedef struct VkVideoDecodeH265CapabilitiesEXT {
VkStructureType sType;
void* pNext;
uint32_t maxLevel;
VkExtensionProperties stdExtensionVersion;
} VkVideoDecodeH265CapabilitiesEXT;
typedef struct VkVideoDecodeH265SessionCreateInfoEXT {
VkStructureType sType;
const void* pNext;
VkVideoDecodeH265CreateFlagsEXT flags;
const VkExtensionProperties* pStdExtensionVersion;
} VkVideoDecodeH265SessionCreateInfoEXT;
typedef struct VkVideoDecodeH265SessionParametersAddInfoEXT {
VkStructureType sType;
const void* pNext;
uint32_t spsStdCount;
const StdVideoH265SequenceParameterSet* pSpsStd;
uint32_t ppsStdCount;
const StdVideoH265PictureParameterSet* pPpsStd;
} VkVideoDecodeH265SessionParametersAddInfoEXT;
typedef struct VkVideoDecodeH265SessionParametersCreateInfoEXT {
VkStructureType sType;
const void* pNext;
uint32_t maxSpsStdCount;
uint32_t maxPpsStdCount;
const VkVideoDecodeH265SessionParametersAddInfoEXT* pParametersAddInfo;
} VkVideoDecodeH265SessionParametersCreateInfoEXT;
typedef struct VkVideoDecodeH265PictureInfoEXT {
VkStructureType sType;
const void* pNext;
StdVideoDecodeH265PictureInfo* pStdPictureInfo;
uint32_t slicesCount;
const uint32_t* pSlicesDataOffsets;
} VkVideoDecodeH265PictureInfoEXT;
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( typedef struct VkVideoDecodeH265DpbSlotInfoEXT {
VkDevice device, VkStructureType sType;
VkPipeline pipeline, const void* pNext;
uint32_t firstGroup, const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo;
uint32_t groupCount, } VkVideoDecodeH265DpbSlotInfoEXT;
size_t dataSize,
void* pData);
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(
VkCommandBuffer commandBuffer,
const VkStridedBufferRegionKHR* pRaygenShaderBindingTable,
const VkStridedBufferRegionKHR* pMissShaderBindingTable,
const VkStridedBufferRegionKHR* pHitShaderBindingTable,
const VkStridedBufferRegionKHR* pCallableShaderBindingTable,
VkBuffer buffer,
VkDeviceSize offset);
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(
VkDevice device,
const VkAccelerationStructureVersionKHR* version);
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }
......
include/vulkan/vulkan_core.h
This source diff could not be displayed because it is too large. You can view the blob instead.
include/vulkan/vulkan_directfb.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_DIRECTFB_H_ 1 #define VULKAN_DIRECTFB_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
include/vulkan/vulkan_fuchsia.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_FUCHSIA_H_ 1 #define VULKAN_FUCHSIA_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
...@@ -40,6 +40,80 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA( ...@@ -40,6 +40,80 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(
VkSurfaceKHR* pSurface); VkSurfaceKHR* pSurface);
#endif #endif
#define VK_FUCHSIA_external_memory 1
#define VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION 1
#define VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME "VK_FUCHSIA_external_memory"
typedef struct VkImportMemoryZirconHandleInfoFUCHSIA {
VkStructureType sType;
const void* pNext;
VkExternalMemoryHandleTypeFlagBits handleType;
zx_handle_t handle;
} VkImportMemoryZirconHandleInfoFUCHSIA;
typedef struct VkMemoryZirconHandlePropertiesFUCHSIA {
VkStructureType sType;
void* pNext;
uint32_t memoryTypeBits;
} VkMemoryZirconHandlePropertiesFUCHSIA;
typedef struct VkMemoryGetZirconHandleInfoFUCHSIA {
VkStructureType sType;
const void* pNext;
VkDeviceMemory memory;
VkExternalMemoryHandleTypeFlagBits handleType;
} VkMemoryGetZirconHandleInfoFUCHSIA;
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle);
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(
VkDevice device,
const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
zx_handle_t* pZirconHandle);
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(
VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
zx_handle_t zirconHandle,
VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
#endif
#define VK_FUCHSIA_external_semaphore 1
#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_FUCHSIA_external_semaphore"
typedef struct VkImportSemaphoreZirconHandleInfoFUCHSIA {
VkStructureType sType;
const void* pNext;
VkSemaphore semaphore;
VkSemaphoreImportFlags flags;
VkExternalSemaphoreHandleTypeFlagBits handleType;
zx_handle_t zirconHandle;
} VkImportSemaphoreZirconHandleInfoFUCHSIA;
typedef struct VkSemaphoreGetZirconHandleInfoFUCHSIA {
VkStructureType sType;
const void* pNext;
VkSemaphore semaphore;
VkExternalSemaphoreHandleTypeFlagBits handleType;
} VkSemaphoreGetZirconHandleInfoFUCHSIA;
typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(
VkDevice device,
const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(
VkDevice device,
const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
zx_handle_t* pZirconHandle);
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
......
include/vulkan/vulkan_fuchsia_extras.h
...@@ -149,82 +149,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA( ...@@ -149,82 +149,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA(
VkBufferCollectionPropertiesFUCHSIA* pProperties); VkBufferCollectionPropertiesFUCHSIA* pProperties);
#endif #endif
#define VK_FUCHSIA_external_memory 1
#define VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION 1
#define VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME "VK_FUCHSIA_external_memory"
typedef struct VkImportMemoryZirconHandleInfoFUCHSIA {
VkStructureType sType;
const void* pNext;
VkExternalMemoryHandleTypeFlagBits handleType;
zx_handle_t handle;
} VkImportMemoryZirconHandleInfoFUCHSIA;
typedef struct VkMemoryZirconHandlePropertiesFUCHSIA {
VkStructureType sType;
void* pNext;
uint32_t memoryTypeBits;
} VkMemoryZirconHandlePropertiesFUCHSIA;
typedef struct VkMemoryGetZirconHandleInfoFUCHSIA {
VkStructureType sType;
const void* pNext;
VkDeviceMemory memory;
VkExternalMemoryHandleTypeFlagBits handleType;
} VkMemoryGetZirconHandleInfoFUCHSIA;
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle);
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t ZirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(
VkDevice device,
const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
zx_handle_t* pZirconHandle);
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(
VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
zx_handle_t ZirconHandle,
VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
#endif
#define VK_FUCHSIA_external_semaphore 1
#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_FUCHSIA_external_semaphore"
typedef struct VkImportSemaphoreZirconHandleInfoFUCHSIA {
VkStructureType sType;
const void* pNext;
VkSemaphore semaphore;
VkSemaphoreImportFlags flags;
VkExternalSemaphoreHandleTypeFlagBits handleType;
zx_handle_t handle;
} VkImportSemaphoreZirconHandleInfoFUCHSIA;
typedef struct VkSemaphoreGetZirconHandleInfoFUCHSIA {
VkStructureType sType;
const void* pNext;
VkSemaphore semaphore;
VkExternalSemaphoreHandleTypeFlagBits handleType;
} VkSemaphoreGetZirconHandleInfoFUCHSIA;
typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(
VkDevice device,
const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(
VkDevice device,
const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
zx_handle_t* pZirconHandle);
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
......
include/vulkan/vulkan_ggp.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_GGP_H_ 1 #define VULKAN_GGP_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
include/vulkan/vulkan_ios.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_IOS_H_ 1 #define VULKAN_IOS_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
include/vulkan/vulkan_macos.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_MACOS_H_ 1 #define VULKAN_MACOS_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
include/vulkan/vulkan_metal.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_METAL_H_ 1 #define VULKAN_METAL_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
include/vulkan/vulkan_screen.h 0 → 100644
#ifndef VULKAN_SCREEN_H_
#define VULKAN_SCREEN_H_ 1
/*
** Copyright 2015-2021 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/
/*
** This header is generated from the Khronos Vulkan XML API Registry.
**
*/
#ifdef __cplusplus
extern "C" {
#endif
#define VK_QNX_screen_surface 1
#define VK_QNX_SCREEN_SURFACE_SPEC_VERSION 1
#define VK_QNX_SCREEN_SURFACE_EXTENSION_NAME "VK_QNX_screen_surface"
typedef VkFlags VkScreenSurfaceCreateFlagsQNX;
typedef struct VkScreenSurfaceCreateInfoQNX {
VkStructureType sType;
const void* pNext;
VkScreenSurfaceCreateFlagsQNX flags;
struct _screen_context* context;
struct _screen_window* window;
} VkScreenSurfaceCreateInfoQNX;
typedef VkResult (VKAPI_PTR *PFN_vkCreateScreenSurfaceQNX)(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(
VkInstance instance,
const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface);
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
struct _screen_window* window);
#endif
#ifdef __cplusplus
}
#endif
#endif
include/vulkan/vulkan_vi.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_VI_H_ 1 #define VULKAN_VI_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
include/vulkan/vulkan_wayland.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_WAYLAND_H_ 1 #define VULKAN_WAYLAND_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
include/vulkan/vulkan_win32.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_WIN32_H_ 1 #define VULKAN_WIN32_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
include/vulkan/vulkan_xcb.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_XCB_H_ 1 #define VULKAN_XCB_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
include/vulkan/vulkan_xlib.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_XLIB_H_ 1 #define VULKAN_XLIB_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
include/vulkan/vulkan_xlib_xrandr.h
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
#define VULKAN_XLIB_XRANDR_H_ 1 #define VULKAN_XLIB_XRANDR_H_ 1
/* /*
** Copyright (c) 2015-2020 The Khronos Group Inc. ** Copyright 2015-2021 The Khronos Group Inc.
** **
** SPDX-License-Identifier: Apache-2.0 ** SPDX-License-Identifier: Apache-2.0
*/ */
......
src/Vulkan/VkStringify.cpp
...@@ -16,7 +16,6 @@ ...@@ -16,7 +16,6 @@
#include "System/Debug.hpp" #include "System/Debug.hpp"
#include <vulkan/vk_ext_provoking_vertex.h>
#include <vulkan/vk_google_filtering_precision.h> #include <vulkan/vk_google_filtering_precision.h>
#define VULKAN_HPP_NO_EXCEPTIONS #define VULKAN_HPP_NO_EXCEPTIONS
#define VULKAN_HPP_NAMESPACE vkhpp #define VULKAN_HPP_NAMESPACE vkhpp
......
src/Vulkan/VulkanPlatform.hpp
...@@ -49,7 +49,6 @@ public: ...@@ -49,7 +49,6 @@ public:
typedef VkNonDispatchableHandle<object##Ptr> object; \ typedef VkNonDispatchableHandle<object##Ptr> object; \
template class VkNonDispatchableHandle<object##Ptr>; template class VkNonDispatchableHandle<object##Ptr>;
#include <vulkan/vk_ext_provoking_vertex.h>
#include <vulkan/vk_google_filtering_precision.h> #include <vulkan/vk_google_filtering_precision.h>
#include <vulkan/vulkan_core.h> #include <vulkan/vulkan_core.h>
...@@ -59,7 +58,7 @@ namespace vk { ...@@ -59,7 +58,7 @@ namespace vk {
// When updating the Vulkan Headers we use, go through each constant below and make sure they are valid. // When updating the Vulkan Headers we use, go through each constant below and make sure they are valid.
// Once that's done, update SwiftShaderVulkanHeaderVersion. // Once that's done, update SwiftShaderVulkanHeaderVersion.
constexpr int SwiftShaderVulkanHeaderVersion = 160; constexpr int SwiftShaderVulkanHeaderVersion = 178;
static_assert(SwiftShaderVulkanHeaderVersion == VK_HEADER_VERSION, "Please validate/update constants below upon upgrading Vulkan headers"); static_assert(SwiftShaderVulkanHeaderVersion == VK_HEADER_VERSION, "Please validate/update constants below upon upgrading Vulkan headers");
constexpr auto VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1); constexpr auto VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1);
......
src/Vulkan/libVulkan.cpp
...@@ -4080,7 +4080,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice d ...@@ -4080,7 +4080,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice d
TRACE("(VkDevice device = %p, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities = %p)", TRACE("(VkDevice device = %p, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities = %p)",
device, pDeviceGroupPresentCapabilities); device, pDeviceGroupPresentCapabilities);
for(int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++) for(unsigned int i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; i++)
{ {
// The only real physical device in the presentation group is device 0, // The only real physical device in the presentation group is device 0,
// and it can present to itself. // and it can present to itself.
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment