vk_layer.h (7878B)
1 // 2 // File: vk_layer.h 3 // 4 /* 5 * Copyright (c) 2015-2017 The Khronos Group Inc. 6 * Copyright (c) 2015-2017 Valve Corporation 7 * Copyright (c) 2015-2017 LunarG, Inc. 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 */ 22 23 /* Need to define dispatch table 24 * Core struct can then have ptr to dispatch table at the top 25 * Along with object ptrs for current and next OBJ 26 */ 27 #pragma once 28 29 #include "vulkan.h" 30 #if defined(__GNUC__) && __GNUC__ >= 4 31 #define VK_LAYER_EXPORT __attribute__((visibility("default"))) 32 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) 33 #define VK_LAYER_EXPORT __attribute__((visibility("default"))) 34 #else 35 #define VK_LAYER_EXPORT 36 #endif 37 38 #define MAX_NUM_UNKNOWN_EXTS 250 39 40 // Loader-Layer version negotiation API. Versions add the following features: 41 // Versions 0/1 - Initial. Doesn't support vk_layerGetPhysicalDeviceProcAddr 42 // or vk_icdNegotiateLoaderLayerInterfaceVersion. 43 // Version 2 - Add support for vk_layerGetPhysicalDeviceProcAddr and 44 // vk_icdNegotiateLoaderLayerInterfaceVersion. 45 #define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2 46 #define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1 47 48 #define VK_CURRENT_CHAIN_VERSION 1 49 50 // Typedef for use in the interfaces below 51 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); 52 53 // Version negotiation values 54 typedef enum VkNegotiateLayerStructType { 55 LAYER_NEGOTIATE_UNINTIALIZED = 0, 56 LAYER_NEGOTIATE_INTERFACE_STRUCT = 1, 57 } VkNegotiateLayerStructType; 58 59 // Version negotiation structures 60 typedef struct VkNegotiateLayerInterface { 61 VkNegotiateLayerStructType sType; 62 void *pNext; 63 uint32_t loaderLayerInterfaceVersion; 64 PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; 65 PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr; 66 PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr; 67 } VkNegotiateLayerInterface; 68 69 // Version negotiation functions 70 typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct); 71 72 // Function prototype for unknown physical device extension command 73 typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device); 74 75 // ------------------------------------------------------------------------------------------------ 76 // CreateInstance and CreateDevice support structures 77 78 /* Sub type of structure for instance and device loader ext of CreateInfo. 79 * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO 80 * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO 81 * then VkLayerFunction indicates struct type pointed to by pNext 82 */ 83 typedef enum VkLayerFunction_ { 84 VK_LAYER_LINK_INFO = 0, 85 VK_LOADER_DATA_CALLBACK = 1, 86 VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2, 87 VK_LOADER_FEATURES = 3, 88 } VkLayerFunction; 89 90 typedef struct VkLayerInstanceLink_ { 91 struct VkLayerInstanceLink_ *pNext; 92 PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; 93 PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr; 94 } VkLayerInstanceLink; 95 96 /* 97 * When creating the device chain the loader needs to pass 98 * down information about it's device structure needed at 99 * the end of the chain. Passing the data via the 100 * VkLayerDeviceInfo avoids issues with finding the 101 * exact instance being used. 102 */ 103 typedef struct VkLayerDeviceInfo_ { 104 void *device_info; 105 PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; 106 } VkLayerDeviceInfo; 107 108 typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance, 109 void *object); 110 typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device, 111 void *object); 112 typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, 113 const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA); 114 typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction); 115 116 typedef enum VkLoaderFeastureFlagBits { 117 VK_LOADER_FEATURE_PHYSICAL_DEVICE_SORTING = 0x00000001, 118 } VkLoaderFlagBits; 119 typedef VkFlags VkLoaderFeatureFlags; 120 121 typedef struct { 122 VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO 123 const void *pNext; 124 VkLayerFunction function; 125 union { 126 VkLayerInstanceLink *pLayerInfo; 127 PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData; 128 struct { 129 PFN_vkLayerCreateDevice pfnLayerCreateDevice; 130 PFN_vkLayerDestroyDevice pfnLayerDestroyDevice; 131 } layerDevice; 132 VkLoaderFeatureFlags loaderFeatures; 133 } u; 134 } VkLayerInstanceCreateInfo; 135 136 typedef struct VkLayerDeviceLink_ { 137 struct VkLayerDeviceLink_ *pNext; 138 PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; 139 PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr; 140 } VkLayerDeviceLink; 141 142 typedef struct { 143 VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO 144 const void *pNext; 145 VkLayerFunction function; 146 union { 147 VkLayerDeviceLink *pLayerInfo; 148 PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData; 149 } u; 150 } VkLayerDeviceCreateInfo; 151 152 #ifdef __cplusplus 153 extern "C" { 154 #endif 155 156 VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct); 157 158 typedef enum VkChainType { 159 VK_CHAIN_TYPE_UNKNOWN = 0, 160 VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1, 161 VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2, 162 VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3, 163 } VkChainType; 164 165 typedef struct VkChainHeader { 166 VkChainType type; 167 uint32_t version; 168 uint32_t size; 169 } VkChainHeader; 170 171 typedef struct VkEnumerateInstanceExtensionPropertiesChain { 172 VkChainHeader header; 173 VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *, 174 VkExtensionProperties *); 175 const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink; 176 177 #if defined(__cplusplus) 178 inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const { 179 return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties); 180 } 181 #endif 182 } VkEnumerateInstanceExtensionPropertiesChain; 183 184 typedef struct VkEnumerateInstanceLayerPropertiesChain { 185 VkChainHeader header; 186 VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *); 187 const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink; 188 189 #if defined(__cplusplus) 190 inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const { 191 return pfnNextLayer(pNextLink, pPropertyCount, pProperties); 192 } 193 #endif 194 } VkEnumerateInstanceLayerPropertiesChain; 195 196 typedef struct VkEnumerateInstanceVersionChain { 197 VkChainHeader header; 198 VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *); 199 const struct VkEnumerateInstanceVersionChain *pNextLink; 200 201 #if defined(__cplusplus) 202 inline VkResult CallDown(uint32_t *pApiVersion) const { 203 return pfnNextLayer(pNextLink, pApiVersion); 204 } 205 #endif 206 } VkEnumerateInstanceVersionChain; 207 208 #ifdef __cplusplus 209 } 210 #endif